Move sticky keys files to their own directory and rename to StickyKeysController.

ash/sticky_keys/sticky_keys_controller.h

 // 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.
 
-#ifndef ASH_WM_STICKY_KEYS_H_
-#define ASH_WM_STICKY_KEYS_H_
+#ifndef ASH_WM_STICKY_KEYS_CONTROLLER_H_
+#define ASH_WM_STICKY_KEYS_CONTROLLER_H_
 
 #include "ash/ash_export.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 
 namespace ui {
 class Event;
 class KeyEvent;
 class MouseEvent;
 }  // namespace ui
 
 namespace aura {
 class Window;
 }  // namespace aura
 
 namespace ash {
 
 class StickyKeysHandler;
 
-// StickyKeys is an accessibility feature for users to be able to compose key
-// and mouse event with modifier keys without simultaneous key press event.
-// Instead they can compose events separately pressing each of the modifier
-// keys involved.
+// StickyKeysController is an accessibility feature for users to be able to
+// compose key and mouse event with modifier keys without simultaneous key
+// press event. Instead they can compose events separately pressing each of the
+// modifier keys involved.
 // e.g. Composing Ctrl + T
 //       User Action   : The KeyEvent widget will receives
 // ----------------------------------------------------------
 // 1. Press Ctrl key   : Ctrl Keydown.
 // 2. Release Ctrl key : No event
 // 3. Press T key      : T keydown event with ctrl modifier.
 // 4.                  : Ctrl Keyup
 // 5. Release T key    : T keyup without ctrl modifier (Windows behavior)
 //
 // By typing same modifier keys twice, users can generate bunch of modified key
 // events.
 // e.g. To focus tabs consistently by Ctrl + 1, Ctrl + 2 ...
 //       User Action   : The KeyEvent widget will receives
 // ----------------------------------------------------------
 // 1. Press Ctrl key   : Ctrl Keydown
 // 2. Release Ctrl key : No event
 // 3. Press Ctrl key   : No event
 // 4. Release Ctrl key : No event
 // 5. Press 1 key      : 1 Keydown event with Ctrl modifier.
 // 6. Release 1 key    : 1 Keyup event with Ctrl modifier.
 // 7. Press 2 key      : 2 Keydown event with Ctrl modifier.
 // 8. Release 2 key    : 2 Keyup event with Ctrl modifier.
 // 9. Press Ctrl key   : No event
 // 10. Release Ctrl key: Ctrl Keyup
 //
-// In the case of Chrome OS, StickyKeys supports Shift,Alt,Ctrl modifiers. Each
-// handling or state is performed independently.
+// In the case of Chrome OS, StickyKeysController supports Shift,Alt,Ctrl
+// modifiers. Each handling or state is performed independently.
 //
-// StickyKeys is disabled by default.
-class ASH_EXPORT StickyKeys : public ui::EventHandler {
+// StickyKeysController is disabled by default.
+class ASH_EXPORT StickyKeysController : public ui::EventHandler {
  public:
-  StickyKeys();
-  virtual ~StickyKeys();
+  StickyKeysController();
+  virtual ~StickyKeysController();
 
   // Activate sticky keys to intercept and modify incoming events.
   void Enable(bool enabled);
 
  private:
   // Handles keyboard event. Returns true if Sticky key consumes keyboard event.
   bool HandleKeyEvent(ui::KeyEvent* event);
 
   // Handles mouse event. Returns true if sticky key consumes mouse event.
   bool HandleMouseEvent(ui::MouseEvent* event);
 
   // Handles scroll event. Returns true if sticky key consumes scroll event.
   bool HandleScrollEvent(ui::ScrollEvent* event);
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
 
   // Whether sticky keys is activated and modifying events.
   bool enabled_;
 
   // Sticky key handlers.
   scoped_ptr<StickyKeysHandler> shift_sticky_key_;
   scoped_ptr<StickyKeysHandler> alt_sticky_key_;
   scoped_ptr<StickyKeysHandler> ctrl_sticky_key_;
 
-  DISALLOW_COPY_AND_ASSIGN(StickyKeys);
+  DISALLOW_COPY_AND_ASSIGN(StickyKeysController);
 };
 
-// StickyKeysHandler handles key event and performs StickyKeys for specific
+// StickyKeysHandler handles key event and controls sticky keysfor specific
 // modifier keys. If monitored keyboard events are recieved, StickyKeysHandler
 // changes internal state. If non modifier keyboard events or mouse events are
 // received, StickyKeysHandler will append modifier based on internal state.
 // For other events, StickyKeysHandler does nothing.
 //
 // The DISABLED state is default state and any incoming non modifier keyboard
 // events will not be modified. The ENABLED state is one shot modification
 // state. Only next keyboard event will be modified. After that, internal state
 // will be back to DISABLED state with sending modifier keyup event. In the case
 // of LOCKED state, all incomming keyboard events will be modified. The LOCKED
@@ skipping 125 matching lines @@
   // The modifier up key event to be sent on non modifier key on ENABLED state.
   scoped_ptr<ui::KeyEvent> modifier_up_event_;
 
   scoped_ptr<StickyKeysHandlerDelegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(StickyKeysHandler);
 };
 
 }  // namespace ash
 
-#endif  // ASH_WM_STICKY_KEYS_H_
+#endif  // ASH_WM_STICKY_KEYS_CONTROLLER_H_