Convert sticky keys to a chromeos::EventRewriter phase.

chrome/browser/chromeos/events/event_rewriter.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_
 #define CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/events/event.h"
 #include "ui/events/event_rewriter.h"
 
 #if defined(USE_X11)
 #include "chrome/browser/chromeos/device_hierarchy_observer.h"
 #include "ui/events/platform/platform_event_observer.h"
 typedef union _XEvent XEvent;
 #endif
 
 class PrefService;
 
+namespace ash {
+class StickyKeysController;
+}
+
 namespace chromeos {
 namespace input_method {
 class ImeKeyboard;
 }
 
 // EventRewriter makes various changes to keyboard-related events,
 // including KeyEvents and some other events with keyboard modifier flags:
 // - maps modifiers keys (Control, Alt, Search, Caps, Diamond) according
 //   to user preferences;
 // - maps Command to Control on Apple keyboards;
 // - converts numeric pad editing keys to their numeric forms;
 // - converts top-row function keys to special keys where necessary;
 // - handles various key combinations like Search+Backspace -> Delete
 //   and Search+number to Fnumber;
 // - handles key/pointer combinations like Alt+Button1 -> Button3.
 class EventRewriter
     :
 #if defined(USE_X11)
       public DeviceHierarchyObserver,
       public ui::PlatformEventObserver,
 #endif
       public ui::EventRewriter {
  public:
   enum DeviceType {
     kDeviceUnknown = 0,
     kDeviceAppleKeyboard,
   };
 
-  EventRewriter();
+  // Does not take ownership of the |sticky_keys_controller|, which may also
+  // be NULL (for testing without ash), in which case sticky key operations
+  // don't happen.
+  explicit EventRewriter(ash::StickyKeysController* sticky_keys_controller);
   virtual ~EventRewriter();
 
   // Calls DeviceAddedInternal.
   DeviceType DeviceAddedForTesting(int device_id,
                                    const std::string& device_name);
 
   // Calls RewriteLocatedEvent().
   void RewriteLocatedEventForTesting(const ui::Event& event, int* flags);
 
 #if defined(USE_X11)
@@ skipping 26 matching lines @@
   virtual void WillProcessEvent(const ui::PlatformEvent& event) OVERRIDE;
   virtual void DidProcessEvent(const ui::PlatformEvent& event) OVERRIDE;
 
   // DeviceHierarchyObserver:
   virtual void DeviceHierarchyChanged() OVERRIDE;
   virtual void DeviceAdded(int device_id) OVERRIDE;
   virtual void DeviceRemoved(int device_id) OVERRIDE;
 #endif
 
  private:
-  // Things that internal rewriter phases can change about an Event.
+  // Things that keyboard-related rewriter phases can change about an Event.
   struct MutableKeyState {
     int flags;
     ui::KeyboardCode key_code;
   };
 
   // Tables of direct remappings for |RewriteWithKeyboardRemappingsByKeyCode()|.
   struct KeyboardRemapping {
     ui::KeyboardCode input_key_code;
     int input_flags;
     ui::KeyboardCode output_key_code;
@@ skipping 32 matching lines @@
   bool RewriteWithKeyboardRemappingsByKeyCode(
       const KeyboardRemapping* remappings,
       size_t num_remappings,
       const MutableKeyState& input,
       MutableKeyState* remapped_state);
 
   // Rewrite a particular kind of event.
   ui::EventRewriteStatus RewriteKeyEvent(
       const ui::KeyEvent& key_event,
       scoped_ptr<ui::Event>* rewritten_event);
-  ui::EventRewriteStatus RewriteMouseEvent(
+  ui::EventRewriteStatus RewriteMouseButtonEvent(
       const ui::MouseEvent& mouse_event,
       scoped_ptr<ui::Event>* rewritten_event);
+  ui::EventRewriteStatus RewriteMouseWheelEvent(
+      const ui::MouseWheelEvent& mouse_event,
+      scoped_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteTouchEvent(
       const ui::TouchEvent& touch_event,
       scoped_ptr<ui::Event>* rewritten_event);
+  ui::EventRewriteStatus RewriteScrollEvent(
+      const ui::ScrollEvent& scroll_event,
+      scoped_ptr<ui::Event>* rewritten_event);
 
   // Rewriter phases. These can inspect the original |event|, but operate using
   // the current |state|, which may have been modified by previous phases.
   void RewriteModifierKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteNumPadKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteExtendedKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteFunctionKeys(const ui::KeyEvent& event, MutableKeyState* state);
   void RewriteLocatedEvent(const ui::Event& event, int* flags);
 
   // A set of device IDs whose press event has been rewritten.
   std::set<int> pressed_device_ids_;
 
   std::map<int, DeviceType> device_id_to_type_;
   int last_device_id_;
 
   chromeos::input_method::ImeKeyboard* ime_keyboard_for_testing_;
   const PrefService* pref_service_for_testing_;
 
+  // The sticky keys controller is not owned here;
+  // at time of writing it is a singleton in ash::Shell>
+  ash::StickyKeysController* sticky_keys_controller_;
+
   DISALLOW_COPY_AND_ASSIGN(EventRewriter);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_