Rewrite release event only if press event was rewritten for a given device.

chrome/browser/ui/ash/event_rewriter_unittest.cc

 // Copyright (c) 2012 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 "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_member.h"
 #include "base/strings/stringprintf.h"
@@ skipping 11 matching lines @@
 #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 "chromeos/chromeos_switches.h"
 #include "chromeos/ime/mock_xkeyboard.h"
 #include "ui/aura/window.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,
                                       ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type,
                                       KeyCode x_keycode,
                                       unsigned int x_state) {
@@ skipping 14 matching lines @@
                                       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 {
  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)),
@@ skipping 97 matching lines @@
 
   virtual void TearDown() {
     // Shutdown() deletes the IME mock object.
     chromeos::input_method::Shutdown();
   }
 
  protected:
   void TestRewriteNumPadKeys();
   void TestRewriteNumPadKeysOnAppleKeyboard();
 
+  void RewriteLocatedEvent(EventRewriter* rewriter,
+                           ui::LocatedEvent* event) {
+    rewriter->RewriteLocatedEvent(event);
+  }
+
   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_;
   const KeyCode keycode_meta_l_;
   const KeyCode keycode_meta_r_;
@@ skipping 70 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_;
 };
 
-}  // namespace
 #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.
@@ skipping 2089 matching lines @@
   ASSERT_FALSE(RewriteFunctionKeys(&press_f1));
   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_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;
+  rewriter.set_pref_service_for_testing(&prefs);
+  const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN;
+  {
+    ui::ScopedXI2Event xev;
+    xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, kLeftAndAltFlag);
+    ui::MouseEvent press(xev);
+    // Sanity check.
+    EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
+    EXPECT_EQ(kLeftAndAltFlag, press.flags());
+
+    RewriteLocatedEvent(&rewriter, &press);
+
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & press.flags());
+  }
+  {
+    ui::ScopedXI2Event xev;
+    xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, kLeftAndAltFlag);
+    ui::MouseEvent release(xev);
+    RewriteLocatedEvent(&rewriter, &release);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & release.flags());
+  }
+
+  // No ALT in frst click.
+  {
+    ui::ScopedXI2Event xev;
+    xev.InitGenericButtonEvent(
+        10, ui::ET_MOUSE_PRESSED, ui::EF_LEFT_MOUSE_BUTTON);
+    ui::MouseEvent press(xev);
+    RewriteLocatedEvent(&rewriter, &press);
+    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & press.flags());
+  }
+  {
+    ui::ScopedXI2Event xev;
+    xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, kLeftAndAltFlag);
+    ui::MouseEvent release(xev);
+    RewriteLocatedEvent(&rewriter, &release);
+    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) &
+                release.flags());
+  }
+
+  // ALT on different device.
+  {
+    ui::ScopedXI2Event xev;
+    xev.InitGenericButtonEvent(11, ui::ET_MOUSE_PRESSED, kLeftAndAltFlag);
+    ui::MouseEvent press(xev);
+    RewriteLocatedEvent(&rewriter, &press);
+    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & press.flags());
+  }
+  {
+    ui::ScopedXI2Event xev;
+    xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, kLeftAndAltFlag);
+    ui::MouseEvent release(xev);
+    RewriteLocatedEvent(&rewriter, &release);
+    EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) &
+                release.flags());
+  }
+  {
+    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