Show overlay displaying the state of all sticky keys when it is enabled.

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"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #undef RootWindow
 #endif
 
+#include "ash/sticky_keys/sticky_keys_overlay.h"
 #include "base/basictypes.h"
 #include "base/debug/stack_trace.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 namespace ash {
 
 namespace {
 
+ui::EventFlags EventFlagForModifier(StickyKeyModifier modifier) {
+  switch (modifier) {

[James Cook, 2014/01/15 22:53:53]

It's unfortunate you need to have your own set of modifier flags. I chatted with
sky@ -- he would be OK with adding ui::EF_SEARCH_DOWN (similar to how we have
EF_COMMAND_DOWN for Mac OS).  Would that make things easier for you?

I'm not sure what implications that would have for the rest of the input stack,
but it might make eventual sticky-search support easier.

[Tim Song, 2014/01/16 00:01:59]

It would certainly be cleaner and I think a bit more consistent, as the ChromeOS
EventRewriter is using the Mod4Mask XEvent flag rather than a more platform
independent one search flag.

[James Cook, 2014/01/16 00:46:20]

So do you want to make that change in this patch?  Or a follow-up one?

Given that search doesn't work yet do you want to remove the STICKY_KEY_SEARCH
constant from this patch?

[Tim Song, 2014/01/16 01:59:45]

Let's do this in a separate patch. I removed the modifier enum and the search
key.

+    case STICKY_KEY_SHIFT:
+      return ui::EF_SHIFT_DOWN;
+    case STICKY_KEY_ALT:
+      return ui::EF_ALT_DOWN;
+    case STICKY_KEY_CONTROL:
+      return ui::EF_CONTROL_DOWN;
+    case STICKY_KEY_SEARCH:
+      return ui::EF_NONE;
+  }
+  return ui::EF_NONE;
+}
+
 // Returns true if the type of mouse event should be modified by sticky keys.
 bool ShouldModifyMouseEvent(ui::MouseEvent* event) {
   ui::EventType type = event->type();
   return type == ui::ET_MOUSE_PRESSED || type == ui::ET_MOUSE_RELEASED ||
          type == ui::ET_MOUSEWHEEL;
 }
 
 // An implementation of StickyKeysHandler::StickyKeysHandlerDelegate.
 class StickyKeysHandlerDelegateImpl :
     public StickyKeysHandler::StickyKeysHandlerDelegate {
@@ skipping 47 matching lines @@
   DCHECK(target);
   target->GetDispatcher()->AsWindowTreeHostDelegate()
       ->OnHostScrollEvent(event);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeys
 StickyKeysController::StickyKeysController()
-    : enabled_(false),
-      shift_sticky_key_(
-          new StickyKeysHandler(ui::EF_SHIFT_DOWN,
-                              new StickyKeysHandlerDelegateImpl())),
-      alt_sticky_key_(
-          new StickyKeysHandler(ui::EF_ALT_DOWN,
-                                new StickyKeysHandlerDelegateImpl())),
-      ctrl_sticky_key_(
-          new StickyKeysHandler(ui::EF_CONTROL_DOWN,
-                                new StickyKeysHandlerDelegateImpl())) {
+    : enabled_(false) {
 }
 
 StickyKeysController::~StickyKeysController() {
 }
 
 void StickyKeysController::Enable(bool enabled) {
   if (enabled_ != enabled) {
     enabled_ = enabled;
 
     // Reset key handlers when activating sticky keys to ensure all
     // the handlers' states are reset.
     if (enabled_) {
       shift_sticky_key_.reset(
-          new StickyKeysHandler(ui::EF_SHIFT_DOWN,
-                              new StickyKeysHandlerDelegateImpl()));
+          new StickyKeysHandler(STICKY_KEY_SHIFT,
+                                new StickyKeysHandlerDelegateImpl()));
       alt_sticky_key_.reset(
-          new StickyKeysHandler(ui::EF_ALT_DOWN,
+          new StickyKeysHandler(STICKY_KEY_ALT,
                                 new StickyKeysHandlerDelegateImpl()));
       ctrl_sticky_key_.reset(
-          new StickyKeysHandler(ui::EF_CONTROL_DOWN,
+          new StickyKeysHandler(STICKY_KEY_CONTROL,
                                 new StickyKeysHandlerDelegateImpl()));
+
+      overlay_.reset(new StickyKeysOverlay());
+    } else if (overlay_.get()) {
+      overlay_->Show(false);
     }
   }
 }
 
 bool StickyKeysController::HandleKeyEvent(ui::KeyEvent* event) {
   return shift_sticky_key_->HandleKeyEvent(event) ||
       alt_sticky_key_->HandleKeyEvent(event) ||
       ctrl_sticky_key_->HandleKeyEvent(event);
 }
 
 bool StickyKeysController::HandleMouseEvent(ui::MouseEvent* event) {
   return shift_sticky_key_->HandleMouseEvent(event) ||
       alt_sticky_key_->HandleMouseEvent(event) ||
       ctrl_sticky_key_->HandleMouseEvent(event);
 }
 
 bool StickyKeysController::HandleScrollEvent(ui::ScrollEvent* event) {
   return shift_sticky_key_->HandleScrollEvent(event) ||
       alt_sticky_key_->HandleScrollEvent(event) ||
       ctrl_sticky_key_->HandleScrollEvent(event);
 }
 
 void StickyKeysController::OnKeyEvent(ui::KeyEvent* event) {
   // Do not consume a translated key event which is generated by an IME.
   if (event->type() == ui::ET_TRANSLATED_KEY_PRESS ||
       event->type() == ui::ET_TRANSLATED_KEY_RELEASE) {
     return;
   }
 
-  if (enabled_ && HandleKeyEvent(event))
-    event->StopPropagation();
+  if (enabled_) {
+    if (HandleKeyEvent(event))
+      event->StopPropagation();
+    UpdateOverlay();
+  }
 }
 
 void StickyKeysController::OnMouseEvent(ui::MouseEvent* event) {
-  if (enabled_ && HandleMouseEvent(event))
-    event->StopPropagation();
+  if (enabled_) {
+    if (HandleMouseEvent(event))
+      event->StopPropagation();
+    UpdateOverlay();
+  }
 }
 
 void StickyKeysController::OnScrollEvent(ui::ScrollEvent* event) {
-  if (enabled_ && HandleScrollEvent(event))
-    event->StopPropagation();
+  if (enabled_) {
+    if (HandleScrollEvent(event))
+      event->StopPropagation();
+    UpdateOverlay();
+  }
+}
+
+void StickyKeysController::UpdateOverlay() {
+  overlay_->SetModifierKeyState(
+      STICKY_KEY_SHIFT, shift_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(
+      STICKY_KEY_CONTROL, ctrl_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(
+      STICKY_KEY_ALT, alt_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 ||
+      ctrl_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 target_modifier_flag,
+StickyKeysHandler::StickyKeysHandler(StickyKeyModifier modifier,
                                      StickyKeysHandlerDelegate* delegate)
-    : modifier_flag_(target_modifier_flag),
-      current_state_(DISABLED),
+    : modifier_(modifier),
+      modifier_flag_(EventFlagForModifier(modifier_)),
+      current_state_(STICKY_KEY_STATE_DISABLED),
       event_from_myself_(false),
       preparing_to_enable_(false),
       scroll_delta_(0),
       delegate_(delegate) {
 }
 
 StickyKeysHandler::~StickyKeysHandler() {
 }
 
 StickyKeysHandler::StickyKeysHandlerDelegate::StickyKeysHandlerDelegate() {
 }
 
 StickyKeysHandler::StickyKeysHandlerDelegate::~StickyKeysHandlerDelegate() {
 }
 
 bool StickyKeysHandler::HandleKeyEvent(ui::KeyEvent* event) {
   if (event_from_myself_)
     return false;  // Do not handle self-generated key event.
   switch (current_state_) {
-    case DISABLED:
+    case STICKY_KEY_STATE_DISABLED:
       return HandleDisabledState(event);
-    case ENABLED:
+    case STICKY_KEY_STATE_ENABLED:
       return HandleEnabledState(event);
-    case LOCKED:
+    case STICKY_KEY_STATE_LOCKED:
       return HandleLockedState(event);
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleMouseEvent(ui::MouseEvent* event) {
   if (ShouldModifyMouseEvent(event))
     preparing_to_enable_ = false;
 
-  if (event_from_myself_ || current_state_ == DISABLED
+  if (event_from_myself_ || current_state_ == STICKY_KEY_STATE_DISABLED
       || !ShouldModifyMouseEvent(event)) {
     return false;
   }
-  DCHECK(current_state_ == ENABLED || current_state_ == LOCKED);
+  DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
+         current_state_ == STICKY_KEY_STATE_LOCKED);
 
   AppendModifier(event);
   // Only disable on the mouse released event in normal, non-locked mode.
-  if (current_state_ == ENABLED && event->type() != ui::ET_MOUSE_PRESSED) {
-    current_state_ = DISABLED;
+  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
+      event->type() != ui::ET_MOUSE_PRESSED) {
+    current_state_ = STICKY_KEY_STATE_DISABLED;
     DispatchEventAndReleaseModifier(event);
     return true;
   }
 
   return false;
 }
 
 bool StickyKeysHandler::HandleScrollEvent(ui::ScrollEvent* event) {
   preparing_to_enable_ = false;
-  if (event_from_myself_ || current_state_ == DISABLED)
+  if (event_from_myself_ || current_state_ == STICKY_KEY_STATE_DISABLED)
     return false;
-  DCHECK(current_state_ == ENABLED || current_state_ == LOCKED);
+  DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
+         current_state_ == STICKY_KEY_STATE_LOCKED);
 
   // We detect a direction change if the current |scroll_delta_| is assigned
   // and the offset of the current scroll event has the opposing sign.
   bool direction_changed = false;
-  if (current_state_ == ENABLED && event->type() == ui::ET_SCROLL) {
+  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
+      event->type() == ui::ET_SCROLL) {
     int offset = event->y_offset();
     if (scroll_delta_)
       direction_changed = offset * scroll_delta_ <= 0;
     scroll_delta_ = offset;
   }
 
   if (!direction_changed)
     AppendModifier(event);
 
   // We want to modify all the scroll events in the scroll sequence, which ends
   // with a fling start event. We also stop when the scroll sequence changes
   // direction.
-  if (current_state_ == ENABLED &&
+  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
       (event->type() == ui::ET_SCROLL_FLING_START || direction_changed)) {
-    current_state_ = DISABLED;
+    current_state_ = STICKY_KEY_STATE_DISABLED;
     scroll_delta_ = 0;
     DispatchEventAndReleaseModifier(event);
     return true;
   }
 
   return false;
 }
 
 StickyKeysHandler::KeyEventType
     StickyKeysHandler::TranslateKeyEvent(ui::KeyEvent* event) {
   bool is_target_key = false;
   if (event->key_code() == ui::VKEY_SHIFT ||
       event->key_code() == ui::VKEY_LSHIFT ||
       event->key_code() == ui::VKEY_RSHIFT) {
-    is_target_key = (modifier_flag_ == ui::EF_SHIFT_DOWN);
+    is_target_key = (modifier_ == STICKY_KEY_SHIFT);
   } else if (event->key_code() == ui::VKEY_CONTROL ||
       event->key_code() == ui::VKEY_LCONTROL ||
       event->key_code() == ui::VKEY_RCONTROL) {
-    is_target_key = (modifier_flag_ == ui::EF_CONTROL_DOWN);
+    is_target_key = (modifier_ == STICKY_KEY_CONTROL);
   } else if (event->key_code() == ui::VKEY_MENU ||
       event->key_code() == ui::VKEY_LMENU ||
       event->key_code() == ui::VKEY_RMENU) {
-    is_target_key = (modifier_flag_ == ui::EF_ALT_DOWN);
+    is_target_key = (modifier_ == STICKY_KEY_ALT);
   } else {
     return event->type() == ui::ET_KEY_PRESSED ?
         NORMAL_KEY_DOWN : NORMAL_KEY_UP;
   }
 
   if (is_target_key) {
     return event->type() == ui::ET_KEY_PRESSED ?
         TARGET_MODIFIER_DOWN : TARGET_MODIFIER_UP;
   }
   return event->type() == ui::ET_KEY_PRESSED ?
       OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP;
 }
 
 bool StickyKeysHandler::HandleDisabledState(ui::KeyEvent* event) {
   switch (TranslateKeyEvent(event)) {
     case TARGET_MODIFIER_UP:
       if (preparing_to_enable_) {
         preparing_to_enable_ = false;
         scroll_delta_ = 0;
-        current_state_ = ENABLED;
+        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(ui::KeyEvent* event) {
   switch (TranslateKeyEvent(event)) {
     case NORMAL_KEY_UP:
     case TARGET_MODIFIER_DOWN:
       return true;
     case TARGET_MODIFIER_UP:
-      current_state_ = LOCKED;
+      current_state_ = STICKY_KEY_STATE_LOCKED;
       modifier_up_event_.reset();
       return true;
     case NORMAL_KEY_DOWN: {
-      current_state_ = DISABLED;
+      current_state_ = STICKY_KEY_STATE_DISABLED;
       AppendModifier(event);
       DispatchEventAndReleaseModifier(event);
       return true;
     }
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleLockedState(ui::KeyEvent* event) {
   switch (TranslateKeyEvent(event)) {
     case TARGET_MODIFIER_DOWN:
       return true;
     case TARGET_MODIFIER_UP:
-      current_state_ = DISABLED;
+      current_state_ = STICKY_KEY_STATE_DISABLED;
       return false;
     case NORMAL_KEY_DOWN:
     case NORMAL_KEY_UP:
       AppendModifier(event);
       return false;
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
@@ skipping 26 matching lines @@
   // The action triggered above may have destroyed the event target, in which
   // case we will dispatch the modifier up event to the root window instead.
   aura::Window* modifier_up_target =
       window_tracker.Contains(target) ? target : root_window;
   delegate_->DispatchKeyEvent(modifier_up_event_.get(), modifier_up_target);
   event_from_myself_ = false;
 }
 
 void StickyKeysHandler::AppendNativeEventMask(unsigned int* state) {
   unsigned int& state_ref = *state;
-  switch (modifier_flag_) {
-    case ui::EF_CONTROL_DOWN:
+  switch (modifier_) {
+    case STICKY_KEY_CONTROL:
       state_ref |= ControlMask;
       break;
-    case ui::EF_ALT_DOWN:
+    case STICKY_KEY_ALT:
       state_ref |= Mod1Mask;
       break;
-    case ui::EF_SHIFT_DOWN:
+    case STICKY_KEY_SHIFT:
       state_ref |= ShiftMask;
       break;
+    case STICKY_KEY_SEARCH:
+      break;
     default:
       NOTREACHED();
   }
 }
 
 void StickyKeysHandler::AppendModifier(ui::KeyEvent* event) {
 #if defined(USE_X11)
   XEvent* xev = event->native_event();
   if (xev) {
     XKeyEvent* xkey = &(xev->xkey);
@@ skipping 32 matching lines @@
           &xievent->mods.effective));
     }
   }
 #elif defined(USE_OZONE)
   NOTIMPLEMENTED() << "Modifier key is not handled";
 #endif
   event->set_flags(event->flags() | modifier_flag_);
 }
 
 }  // namespace ash