Move chromeos::EventRewriter to //ui/chromeos/events

ui/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_
+#ifndef UI_CHROMEOS_EVENTS_EVENT_REWRITER_H_
+#define UI_CHROMEOS_EVENTS_EVENT_REWRITER_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
+#include "ui/chromeos/ui_chromeos_export.h"
 #include "ui/events/event.h"
 #include "ui/events/event_rewriter.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 
-class PrefService;
-
-namespace ash {
-class StickyKeysController;
-}
-
-namespace ui {
-enum class DomCode;
-};
-
 namespace chromeos {
 namespace input_method {
 class ImeKeyboard;
 }
+}
+
+namespace ui {
+
+enum class DomCode;
+
+namespace chromeos {
 
 // EventRewriter makes various changes to keyboard-related events,
 // including KeyEvents and some other events with keyboard modifier flags:
 // - maps certain non-character keys according to user preferences
 //   (Control, Alt, Search, Caps Lock, Escape, Backspace, Diamond);
 // - 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 : public ui::EventRewriter {
+class UI_CHROMEOS_EXPORT EventRewriter : public ui::EventRewriter {
  public:
   enum DeviceType {
     kDeviceUnknown = 0,
     kDeviceAppleKeyboard,
     kDeviceHotrodRemote,
     kDeviceVirtualCoreKeyboard,  // X-server generated events.
   };
 
   // Things that keyboard-related rewriter phases can change about an Event.
   struct MutableKeyState {
     int flags;
     ui::DomCode code;
     ui::DomKey::Base key;
     ui::KeyboardCode key_code;
   };
 
+  class StickyKeysController {
+   public:
+    StickyKeysController() {}
+    virtual ~StickyKeysController() {}
+
+    // Handles keyboard event. Returns an |EventRewriteStatus|, and may
+    // modify |flags|:
+    // - Returns ui::EVENT_REWRITE_DISCARD, and leaves |flags| untouched,
+    //   if the event is consumed (i.e. a sticky modifier press or release);
+    // - Returns ui::EVENT_REWRITE_REWRITTEN if the event needs to be modified
+    //   according to the returned |flags| (i.e. a sticky-modified key);
+    // - Returns ui::EVENT_REWRITE_DISPATCH_ANOTHER if the event needs to be
+    //   modified according to the returned |flags|, and there are delayed
+    //   modifier-up   events now to be retrieved using |NextDispatchEvent()|
+    //   (i.e. a sticky-modified key that ends a sticky state);
+    // - Otherwise returns ui::EVENT_REWRITE_CONTINUE and leaves |flags|
+    //   unchanged.
+    virtual ui::EventRewriteStatus RewriteKeyEvent(const ui::KeyEvent& event,
+                                                   ui::KeyboardCode key_code,
+                                                   int* flags) = 0;
+
+    // Handles mouse event.
+    virtual ui::EventRewriteStatus RewriteMouseEvent(
+        const ui::MouseEvent& event,
+        int* flags) = 0;
+
+    // Handles scroll event.
+    virtual ui::EventRewriteStatus RewriteScrollEvent(
+        const ui::ScrollEvent& event,
+        int* flags) = 0;

[sadrul, 2017/03/03 15:11:41]

It looks to me like we don't actually need the StickeKeysController interface
here at all. This EventRewriter can simply take in another ui::EventRewriter,
and use that interface instead. The StickyKeysController overrides of
ui::EventRewriter would make the appropriate calls to RewriteKeyEvent() etc. Is
there something that wouldn't work with that approach?

[Peng, 2017/03/03 16:07:05]

The signatures of EventRewriter is different. It is not straightforward to use
EventRewriter. So I prefer to make this CL simple. How about we do it in a
separate CL?

[sadrul, 2017/03/06 16:54:26]

Separate CL makes sense, but I think we should that first, rather than introduce
this short-lived interface.

+
+    // Obtains a pending modifier-up event. If the immediately previous
+    // call to |Rewrite...Event()| or |NextDispatchEvent()| returned
+    // ui::EVENT_REWRITE_DISPATCH_ANOTHER, this sets |new_event| and returns:
+    // - ui::EVENT_REWRITE_DISPATCH_ANOTHER if there is at least one more
+    //   pending modifier-up event;
+    // - ui::EVENT_REWRITE_REWRITE if this is the last or only modifier-up
+    // event; Otherwise, there is no pending modifier-up event, and this
+    // function returns ui::EVENT_REWRITE_CONTINUE and sets |new_event| to NULL.
+    virtual ui::EventRewriteStatus NextDispatchEvent(
+        std::unique_ptr<ui::Event>* new_event) = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(StickyKeysController);
+  };
+
+  class Delegate {
+   public:
+    Delegate() {}
+    virtual ~Delegate() {}
+
+    virtual bool RewriteModifierKeys() = 0;
+
+    // Returns true if get keyboard remapped preference value successfully and
+    // the value will be stored in |value|.
+    virtual bool GetKeyboardRemappedPrefValue(const std::string& pref_name,
+                                              int* value) const = 0;
+
+    // Returns true if the target would prefer to receive raw
+    // function keys instead of having them rewritten into back, forward,
+    // brightness, volume, etc. or if the user has specified that they desire
+    // top-row keys to be treated as function keys globally.
+    virtual bool TopRowKeysAreFunctionKeys() const = 0;
+
+    // Retunrs true if the key_code and flags have been resgistered for
+    // extensions.
+    virtual bool IsExtensionCommandRegistered(ui::KeyboardCode key_code,
+                                              int flags) const = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Delegate);
+  };
+
   // 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);
+  EventRewriter(Delegate* delegate,
+                StickyKeysController* sticky_keys_controller);
   ~EventRewriter() override;
 
   // Calls KeyboardDeviceAddedInternal.
   DeviceType KeyboardDeviceAddedForTesting(int device_id,
                                            const std::string& device_name);
 
   // Calls RewriteMouseEvent().
   void RewriteMouseButtonEventForTesting(
       const ui::MouseEvent& event,
       std::unique_ptr<ui::Event>* rewritten_event);
 
   const std::map<int, DeviceType>& device_id_to_type_for_testing() const {
     return device_id_to_type_;
   }
   void set_last_keyboard_device_id_for_testing(int device_id) {
     last_keyboard_device_id_ = device_id;
   }
-  void set_pref_service_for_testing(const PrefService* pref_service) {
-    pref_service_for_testing_ = pref_service;
-  }
   void set_ime_keyboard_for_testing(
-      chromeos::input_method::ImeKeyboard* ime_keyboard) {
+      ::chromeos::input_method::ImeKeyboard* ime_keyboard) {
     ime_keyboard_for_testing_ = ime_keyboard;
   }
 
   // EventRewriter overrides:
   ui::EventRewriteStatus RewriteEvent(
       const ui::Event& event,
       std::unique_ptr<ui::Event>* rewritten_event) override;
   ui::EventRewriteStatus NextDispatchEvent(
       const ui::Event& last_event,
       std::unique_ptr<ui::Event>* new_event) override;
 
   // Generate a new key event from an original key event and the replacement
   // state determined by a key rewriter.
   static void BuildRewrittenKeyEvent(
       const ui::KeyEvent& key_event,
       const MutableKeyState& state,
       std::unique_ptr<ui::Event>* rewritten_event);
 
  private:
   void DeviceKeyPressedOrReleased(int device_id);
 
-  // Returns the PrefService that should be used.
-  const PrefService* GetPrefService() const;
-
   // Adds a device to |device_id_to_type_|.
   DeviceType KeyboardDeviceAdded(int device_id);
 
   // Checks the type of the |device_name|, |vendor_id| and |product_id|, and
   // inserts a new entry to |device_id_to_type_|.
   DeviceType KeyboardDeviceAddedInternal(int device_id,
                                          const std::string& device_name,
                                          int vendor_id,
                                          int product_id);
 
   // Returns true if |last_keyboard_device_id_| is Apple's.
   bool IsAppleKeyboard() const;
   // Returns true if |last_keyboard_device_id_| is Hotrod remote.
   bool IsHotrodRemote() const;
   // Returns true if |last_keyboard_device_id_| is of given |device_type|.
   bool IsLastKeyboardOfType(DeviceType device_type) const;
 
-  // Returns true if the target for |event| would prefer to receive raw function
-  // keys instead of having them rewritten into back, forward, brightness,
-  // volume, etc. or if the user has specified that they desire top-row keys to
-  // be treated as function keys globally.
-  bool TopRowKeysAreFunctionKeys(const ui::KeyEvent& event) const;
-
   // Given modifier flags |original_flags|, returns the remapped modifiers
   // according to user preferences and/or event properties.
-  int GetRemappedModifierMasks(const PrefService& pref_service,
-                               const ui::Event& event,
+  int GetRemappedModifierMasks(const ui::Event& event,
                                int original_flags) const;
 
   // Rewrite a particular kind of event.
   ui::EventRewriteStatus RewriteKeyEvent(
       const ui::KeyEvent& key_event,
       std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteMouseButtonEvent(
       const ui::MouseEvent& mouse_event,
       std::unique_ptr<ui::Event>* rewritten_event);
   ui::EventRewriteStatus RewriteMouseWheelEvent(
@@ skipping 18 matching lines @@
   // A set of device IDs whose press event has been rewritten.
   // This is to ensure that press and release events are rewritten consistently.
   std::set<int> pressed_device_ids_;
 
   std::map<int, DeviceType> device_id_to_type_;
 
   // The |source_device_id()| of the most recent keyboard event,
   // used to interpret modifiers on pointer events.
   int last_keyboard_device_id_;
 
-  chromeos::input_method::ImeKeyboard* ime_keyboard_for_testing_;
-  const PrefService* pref_service_for_testing_;
+  ::chromeos::input_method::ImeKeyboard* ime_keyboard_for_testing_;
+
+  Delegate* const delegate_;
 
   // The sticky keys controller is not owned here;
   // at time of writing it is a singleton in ash::Shell.
-  ash::StickyKeysController* sticky_keys_controller_;
+  StickyKeysController* sticky_keys_controller_;
 
   // Some keyboard layouts have 'latching' keys, which either apply
   // a modifier while held down (like normal modifiers), or, if no
   // non-modifier is pressed while the latching key is down, apply the
   // modifier to the next non-modifier keypress. Under Ozone the stateless
   // layout model requires this to be handled explicitly. See crbug.com/518237
   // Pragmatically this, like the Diamond key, is handled here in
   // EventRewriter, but modifier state management is scattered between
   // here, sticky keys, and the system layer (X11 or Ozone), and could
   // do with refactoring.
   // - |pressed_modifier_latches_| records the latching keys currently pressed.
   //   It also records the active modifier flags for non-modifier keys that are
   //   remapped to modifiers, e.g. Diamond/F15.
   // - |latched_modifier_latches_| records the latching keys just released,
   //   to be applied to the next non-modifier key.
   // - |used_modifier_latches_| records the latching keys applied to a non-
   //   modifier while pressed, so that they do not get applied after release.
   int pressed_modifier_latches_;
   int latched_modifier_latches_;
   int used_modifier_latches_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRewriter);
 };
 
 }  // namespace chromeos
+}  // namespace ui
 
-#endif  // CHROME_BROWSER_CHROMEOS_EVENTS_EVENT_REWRITER_H_
+#endif  // UI_CHROMEOS_EVENTS_EVENT_REWRITER_H_