event-rewrite: Clean up how events are rewritten.

chrome/browser/chromeos/event_rewriter_unittest.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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.
 
-#include "chrome/browser/ui/ash/event_rewriter.h"
+#include "chrome/browser/chromeos/event_rewriter.h"
 
+#include <X11/keysym.h>
+#include <X11/XF86keysym.h>
+#include <X11/Xlib.h>
+#undef Bool
+#undef None
+#undef RootWindow
+
+#include "ash/test/ash_test_base.h"
+#include "ash/wm/window_state.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_member.h"
 #include "base/strings/stringprintf.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/base/testing_pref_service_syncable.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/events/event.h"
-
-#if defined(OS_CHROMEOS)
-#include <X11/keysym.h>
-#include <X11/XF86keysym.h>
-#include <X11/Xlib.h>
-
-#include "ash/test/ash_test_base.h"
-#include "ash/wm/window_state.h"
 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/preferences.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/fake_xkeyboard.h"
+#include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/window.h"
+#include "ui/events/event.h"
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace {
 
-std::string GetRewrittenEventAsString(EventRewriter* rewriter,
+std::string GetRewrittenEventAsString(chromeos::EventRewriter* rewriter,
                                       ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type,
                                       KeyCode x_keycode,
                                       unsigned int x_state) {
   ui::ScopedXI2Event xev;
   xev.InitKeyEvent(ui_type, ui_keycode, ui_flags);
   XEvent* xevent = xev;
   xevent->xkey.keycode = x_keycode;
   xevent->xkey.state = x_state;
-  ui::KeyEvent keyevent(xev, false /* is_char */);
-  rewriter->RewriteForTesting(&keyevent);
+  rewriter->RewriteForTesting(xevent);
+  ui::KeyEvent keyevent(xevent, false /* is_char */);
   return base::StringPrintf(
       "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
       keyevent.key_code(), keyevent.flags(), keyevent.type(),
       xevent->xkey.keycode, xevent->xkey.state, xevent->xkey.type);
 }
 
 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type,
                                       KeyCode x_keycode,
                                       unsigned int x_state,
                                       int x_type) {
   return base::StringPrintf(
       "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
       ui_keycode, ui_flags, ui_type, x_keycode, x_state, x_type);
 }
 
 }  // namespace
 
-class EventRewriterTest : public testing::Test {
+namespace chromeos {
+
+class EventRewriterTest : public ash::test::AshTestBase {
  public:
   EventRewriterTest()
       : display_(gfx::GetXDisplay()),
         keycode_a_(XKeysymToKeycode(display_, XK_a)),
         keycode_alt_l_(XKeysymToKeycode(display_, XK_Alt_L)),
         keycode_alt_r_(XKeysymToKeycode(display_, XK_Alt_R)),
         keycode_b_(XKeysymToKeycode(display_, XK_B)),
         keycode_caps_lock_(XKeysymToKeycode(display_, XK_Caps_Lock)),
         keycode_control_l_(XKeysymToKeycode(display_, XK_Control_L)),
         keycode_control_r_(XKeysymToKeycode(display_, XK_Control_R)),
@@ skipping 85 matching lines @@
   virtual ~EventRewriterTest() {}
 
   virtual void SetUp() {
     // Mocking user manager because the real one needs to be called on UI thread
     EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest())
         .WillRepeatedly(testing::Return(false));
     input_method_manager_mock_ =
         new chromeos::input_method::MockInputMethodManager;
     chromeos::input_method::InitializeForTesting(
         input_method_manager_mock_);  // pass ownership
+
+    AshTestBase::SetUp();
   }
 
   virtual void TearDown() {
+    AshTestBase::TearDown();
     // Shutdown() deletes the IME mock object.
     chromeos::input_method::Shutdown();
   }
 
  protected:
   void TestRewriteNumPadKeys();
   void TestRewriteNumPadKeysOnAppleKeyboard();
 
   void RewriteLocatedEvent(EventRewriter* rewriter,

[Daniel Erat, 2014/02/14 15:56:29]

rename this to RewriteMouseEvent() and make it take a MouseEvent instead?

[sadrul, 2014/02/14 17:23:14]

Done.

                            ui::LocatedEvent* event) {
-    rewriter->RewriteLocatedEvent(event);
+    XEvent* xevent = event->native_event();
+    rewriter->RewriteLocatedEvent(xevent);
+    *event = ui::MouseEvent(xevent);
   }
 
   Display* display_;
   const KeyCode keycode_a_;
   const KeyCode keycode_alt_l_;
   const KeyCode keycode_alt_r_;
   const KeyCode keycode_b_;
   const KeyCode keycode_caps_lock_;
   const KeyCode keycode_control_l_;
   const KeyCode keycode_control_r_;
@@ skipping 72 matching lines @@
   const KeyCode keycode_0_;
   const KeyCode keycode_minus_;
   const KeyCode keycode_equal_;
   const KeyCode keycode_period_;
   const KeyCode keycode_insert_;
   chromeos::MockUserManager* mock_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 };
 
-#else
-class EventRewriterTest : public testing::Test {
- public:
-  EventRewriterTest() {}
-  virtual ~EventRewriterTest() {}
-};
-#endif
-
 TEST_F(EventRewriterTest, TestGetDeviceType) {
   // This is the typical string which an Apple keyboard sends.
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             EventRewriter::GetDeviceType("Apple Inc. Apple Keyboard"));
 
   // Other cases we accept.
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             EventRewriter::GetDeviceType("Apple Keyboard"));
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             EventRewriter::GetDeviceType("apple keyboard"));
@@ skipping 33 matching lines @@
   EXPECT_EQ(1U, rewriter.device_id_to_type_for_testing().size());
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             rewriter.DeviceAddedForTesting(1, "Apple Keyboard"));
   EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
   // Try to reuse the first ID.
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             rewriter.DeviceAddedForTesting(0, "Apple Keyboard"));
   EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
 }
 
-#if defined(OS_CHROMEOS)
 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
   // First, test with a PC keyboard.
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter;
   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
   rewriter.set_last_device_id_for_testing(0);
   rewriter.set_pref_service_for_testing(&prefs);
 
   // XK_a, Alt modifier.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
@@ skipping 1865 matching lines @@
       ui::VKEY_F9, keycode_f9_, 0, 0 },
     { ui::VKEY_F10, keycode_f10_, Mod4Mask, 0,
       ui::VKEY_F10, keycode_f10_, 0, 0 },
     { ui::VKEY_F11, keycode_f11_, Mod4Mask, 0,
       ui::VKEY_F11, keycode_f11_, 0, 0 },
     { ui::VKEY_F12, keycode_f12_, Mod4Mask, 0,
       ui::VKEY_F12, keycode_f12_, 0, 0 },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+    // XKeysymToKeycode returns zero for unknown keys. So ignore those.
+    if (tests[i].output_native == 0)
+      continue;
     EXPECT_EQ(GetExpectedResultAsString(tests[i].output,
                                         tests[i].output_mods,
                                         ui::ET_KEY_PRESSED,
                                         tests[i].output_native,
                                         tests[i].output_native_mods,
                                         KeyPress),
               GetRewrittenEventAsString(&rewriter,
                                         tests[i].input,
                                         tests[i].input_mods,
                                         ui::ET_KEY_PRESSED,
@@ skipping 61 matching lines @@
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Send left control press.
   std::string rewritten_event;
   {
     ui::ScopedXI2Event xev;
     xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
     XEvent* xevent = xev;
     xevent->xkey.keycode = keycode_control_l_;
     xevent->xkey.send_event = True;  // XSendEvent() always does this.
+    rewriter.RewriteForTesting(xevent);
     ui::KeyEvent keyevent(xev, false /* is_char */);
-    rewriter.RewriteForTesting(&keyevent);
     rewritten_event = base::StringPrintf(
         "ui_keycode=%d ui_flags=%d ui_type=%d "
         "x_keycode=%u x_state=%u x_type=%d",
         keyevent.key_code(), keyevent.flags(), keyevent.type(),
         xevent->xkey.keycode, xevent->xkey.state, xevent->xkey.type);
   }
 
   // XK_Control_L (left Control key) should NOT be remapped to Alt if send_event
   // flag in the event is True.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
                                       ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_control_l_,
                                       0U,
                                       KeyPress),
             rewritten_event);
 }
 
 // Tests of event rewriting that depend on the Ash window manager.
 class EventRewriterAshTest : public ash::test::AshTestBase {
  public:
   EventRewriterAshTest() {
     chromeos::Preferences::RegisterProfilePrefs(prefs_.registry());
     rewriter_.set_pref_service_for_testing(&prefs_);
   }
   virtual ~EventRewriterAshTest() {}
 
-  bool RewriteFunctionKeys(ui::KeyEvent* event) {
+  bool RewriteFunctionKeys(XEvent* event) {
     return rewriter_.RewriteFunctionKeys(event);
   }
 
  protected:
   TestingPrefServiceSyncable prefs_;
 
  private:
   EventRewriter rewriter_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
 };
 
 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get());
   window_state->Activate();
 
   // Create a simulated keypress of F1 targetted at the window.
   ui::ScopedXI2Event xev_f1;
   KeyCode keycode_f1 = XKeysymToKeycode(gfx::GetXDisplay(), XK_F1);
   xev_f1.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_F1, 0);
   XEvent* xevent = xev_f1;
   xevent->xkey.keycode = keycode_f1;
-  ui::KeyEvent press_f1(xev_f1, false);
-  ui::Event::DispatcherApi dispatch_helper(&press_f1);
-  dispatch_helper.set_target(window.get());
 
   // Simulate an apps v2 window that has requested top row keys as function
   // keys. The event should not be rewritten.
   window_state->set_top_row_keys_are_function_keys(true);
-  ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
+  ASSERT_FALSE(RewriteFunctionKeys(xevent));
+  ui::KeyEvent press_f1(xev_f1, false);
   ASSERT_EQ(ui::VKEY_F1, press_f1.key_code());
 
   // The event should also not be rewritten if the send-function-keys pref is
   // additionally set, for both apps v2 and regular windows.
   BooleanPrefMember send_function_keys_pref;
   send_function_keys_pref.Init(prefs::kLanguageSendFunctionKeys, &prefs_);
   send_function_keys_pref.SetValue(true);
-  ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
+  ASSERT_FALSE(RewriteFunctionKeys(xevent));
+  press_f1 = ui::KeyEvent(xev_f1, false);
   ASSERT_EQ(ui::VKEY_F1, press_f1.key_code());
   window_state->set_top_row_keys_are_function_keys(false);
-  ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
+  ASSERT_FALSE(RewriteFunctionKeys(xevent));
+  press_f1 = ui::KeyEvent(xev_f1, false);
   ASSERT_EQ(ui::VKEY_F1, press_f1.key_code());
 
   // If the pref isn't set when an event is sent to a regular window, F1 is
   // rewritten to the back key.
   send_function_keys_pref.SetValue(false);
-  ASSERT_TRUE(RewriteFunctionKeys(&press_f1));
+  ASSERT_TRUE(RewriteFunctionKeys(xevent));
+  press_f1 = ui::KeyEvent(xev_f1, false);
   ASSERT_EQ(ui::VKEY_BROWSER_BACK, press_f1.key_code());
 }
 
 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
   std::vector<unsigned int> device_list;
   device_list.push_back(10);
   device_list.push_back(11);
   ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter;
@@ skipping 55 matching lines @@
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(11, ui::ET_MOUSE_RELEASED, kLeftAndAltFlag);
     ui::MouseEvent release(xev);
     RewriteLocatedEvent(&rewriter, &release);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & release.flags());
   }
 }
 
-#endif  // OS_CHROMEOS
+}  // namespace chromeos