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

ash/sticky_keys/sticky_keys_controller.cc

Index: ash/sticky_keys/sticky_keys_controller.cc
diff --git a/ash/sticky_keys/sticky_keys_controller.cc b/ash/sticky_keys/sticky_keys_controller.cc
index aad1ee487a8e6bba3ad2a9781b9763af1e90cd10..b059290045a81765f939ecacc5db8aebc1c026ab 100644
--- a/ash/sticky_keys/sticky_keys_controller.cc
+++ b/ash/sticky_keys/sticky_keys_controller.cc
@@ -10,6 +10,7 @@
 #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"
@@ -22,6 +23,20 @@ namespace ash {
 
 namespace {
 
+ui::EventFlags EventFlagForModifier(StickyKeyModifier modifier) {
+  switch (modifier) {
+    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();
@@ -89,16 +104,7 @@ void StickyKeysHandlerDelegateImpl::DispatchScrollEvent(
 ///////////////////////////////////////////////////////////////////////////////
 //  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() {
@@ -112,14 +118,18 @@ void StickyKeysController::Enable(bool enabled) {
     // 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);
     }
   }
 }
@@ -149,26 +159,52 @@ void StickyKeysController::OnKeyEvent(ui::KeyEvent* event) {
     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(

[James Cook, 2014/01/14 00:59:03]

You don't update for the SEARCH key?

[Tim Song, 2014/01/14 03:01:10]

Support for the search key hasn't been implemented yet (tracked in
crbug.com/322118). I looked into it, but unlike the other modifier keys, the
functionality of the search key is mostly driven by rewriting the input events,
and it didn't look trivial to untangle that web.

+      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);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //  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),
@@ -188,11 +224,11 @@ 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();
@@ -203,16 +239,18 @@ 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;
   }
@@ -222,14 +260,16 @@ bool StickyKeysHandler::HandleMouseEvent(ui::MouseEvent* event) {
 
 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;
@@ -242,9 +282,9 @@ bool StickyKeysHandler::HandleScrollEvent(ui::ScrollEvent* 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;
@@ -259,15 +299,15 @@ StickyKeysHandler::KeyEventType
   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;
@@ -287,7 +327,7 @@ bool StickyKeysHandler::HandleDisabledState(ui::KeyEvent* event) {
       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;
       }
@@ -313,11 +353,11 @@ bool StickyKeysHandler::HandleEnabledState(ui::KeyEvent* event) {
     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;
@@ -335,7 +375,7 @@ bool StickyKeysHandler::HandleLockedState(ui::KeyEvent* 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:
@@ -382,16 +422,18 @@ void StickyKeysHandler::DispatchEventAndReleaseModifier(ui::Event* event) {
 
 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();
   }