Fix handling of rewritten-Alt + Button1 -> Button3.

chrome/browser/chromeos/events/event_rewriter.cc

 // 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/chromeos/events/event_rewriter.h"
 
 #include <vector>
 
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
@@ skipping 165 matching lines @@
 }
 
 EventRewriter::DeviceType EventRewriter::DeviceAddedForTesting(
     int device_id,
     const std::string& device_name) {
   return DeviceAddedInternal(device_id, device_name);
 }
 
 void EventRewriter::RewriteLocatedEventForTesting(const ui::Event& event,
                                                   int* flags) {
-  MutableKeyState state = {*flags, ui::VKEY_UNKNOWN};
-  RewriteLocatedEvent(event, &state);
-  *flags = state.flags;
+  RewriteLocatedEvent(event, flags);
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteEvent(
     const ui::Event& event,
     scoped_ptr<ui::Event>* rewritten_event) {
 #if defined(USE_X11)
   // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
   // crbug.com/136465.
   XEvent* xev = event.native_event();
   if (xev && xev->xany.send_event)
     return ui::EVENT_REWRITE_CONTINUE;
 #endif
   switch (event.type()) {
     case ui::ET_KEY_PRESSED:
-    case ui::ET_KEY_RELEASED: {
-      const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
-      MutableKeyState state = {key_event.flags(), key_event.key_code()};
-      RewriteModifierKeys(key_event, &state);
-      RewriteNumPadKeys(key_event, &state);
-      RewriteExtendedKeys(key_event, &state);
-      RewriteFunctionKeys(key_event, &state);
-      if ((key_event.flags() != state.flags) ||
-          (key_event.key_code() != state.key_code)) {
-        ui::KeyEvent* rewritten_key_event = new ui::KeyEvent(key_event);
-        rewritten_event->reset(rewritten_key_event);
-        rewritten_key_event->set_flags(state.flags);
-        rewritten_key_event->set_key_code(state.key_code);
-        rewritten_key_event->set_character(
-            ui::GetCharacterFromKeyCode(state.key_code, state.flags));
-        rewritten_key_event->NormalizeFlags();
-#if defined(USE_X11)
-        xev = rewritten_key_event->native_event();
-        if (xev) {
-          XKeyEvent* xkey = &(xev->xkey);
-          UpdateX11EventMask(state.flags, &xkey->state);
-          xkey->keycode = XKeysymToKeycode(
-              gfx::GetXDisplay(),
-              ui::XKeysymForWindowsKeyCode(state.key_code,
-                                           state.flags & ui::EF_SHIFT_DOWN));
-        }
-#endif
-        return ui::EVENT_REWRITE_REWRITTEN;
-      }
-      return ui::EVENT_REWRITE_CONTINUE;
-    }
+    case ui::ET_KEY_RELEASED:
+      return RewriteKeyEvent(static_cast<const ui::KeyEvent&>(event),
+                             rewritten_event);
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_MOUSE_RELEASED:
+      return RewriteMouseEvent(static_cast<const ui::MouseEvent&>(event),
+                               rewritten_event);
     case ui::ET_TOUCH_PRESSED:
-    case ui::ET_TOUCH_RELEASED: {
-      MutableKeyState state = {event.flags(), ui::VKEY_UNKNOWN};
-      RewriteLocatedEvent(event, &state);
-      if (event.flags() != state.flags) {
-        if (event.IsMouseEvent()) {
-          rewritten_event->reset(
-              new ui::MouseEvent(static_cast<const ui::MouseEvent&>(event)));
-        } else {
-          rewritten_event->reset(
-              new ui::TouchEvent(static_cast<const ui::TouchEvent&>(event)));
-        }
-        rewritten_event->get()->set_flags(state.flags);
-        return ui::EVENT_REWRITE_REWRITTEN;
-      }
-      return ui::EVENT_REWRITE_CONTINUE;
-    }
+    case ui::ET_TOUCH_RELEASED:
+      return RewriteTouchEvent(static_cast<const ui::TouchEvent&>(event),
+                               rewritten_event);
     default:
       return ui::EVENT_REWRITE_CONTINUE;
   }
   NOTREACHED();
 }
 
 ui::EventRewriteStatus EventRewriter::NextDispatchEvent(
     const ui::Event& last_event,
     scoped_ptr<ui::Event>* new_event) {
   NOTREACHED();
@@ skipping 94 matching lines @@
       continue;
     if ((input.flags & map.input_flags) != map.input_flags)
       continue;
     remapped_state->key_code = map.output_key_code;
     remapped_state->flags = (input.flags & ~map.input_flags) | map.output_flags;
     return true;
   }
   return false;
 }
 
+ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
+    const ui::KeyEvent& key_event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
+  MutableKeyState state = {key_event.flags(), key_event.key_code()};
+  RewriteModifierKeys(key_event, &state);
+  RewriteNumPadKeys(key_event, &state);
+  RewriteExtendedKeys(key_event, &state);
+  RewriteFunctionKeys(key_event, &state);
+  if ((key_event.flags() != state.flags) ||
+      (key_event.key_code() != state.key_code)) {
+    ui::KeyEvent* rewritten_key_event = new ui::KeyEvent(key_event);

[sadrul, 2014/05/20 16:46:54]

You need to set status to REWRITTEN here? Do we have a test that fails because
of this omission? If not, can we add one?

Let's instead early return CONTINUE above after line 336, and return REWRITTEN
below in line ~356. (ditto for RewriteMouse and RewriteTouch cases)

+    rewritten_event->reset(rewritten_key_event);
+    rewritten_key_event->set_flags(state.flags);
+    rewritten_key_event->set_key_code(state.key_code);
+    rewritten_key_event->set_character(
+        ui::GetCharacterFromKeyCode(state.key_code, state.flags));
+    rewritten_key_event->NormalizeFlags();
+#if defined(USE_X11)
+    XEvent* xev = rewritten_key_event->native_event();
+    if (xev) {
+      XKeyEvent* xkey = &(xev->xkey);
+      UpdateX11EventMask(rewritten_key_event->flags(), &xkey->state);
+      xkey->keycode = XKeysymToKeycode(
+          gfx::GetXDisplay(),
+          ui::XKeysymForWindowsKeyCode(state.key_code,
+                                       state.flags & ui::EF_SHIFT_DOWN));
+    }
+#endif
+  }
+  return status;
+}
+
+ui::EventRewriteStatus EventRewriter::RewriteMouseEvent(
+    const ui::MouseEvent& mouse_event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
+  int flags = mouse_event.flags();
+  RewriteLocatedEvent(mouse_event, &flags);
+  if (mouse_event.flags() != flags) {
+    status = ui::EVENT_REWRITE_REWRITTEN;
+    ui::MouseEvent* rewritten_mouse_event = new ui::MouseEvent(mouse_event);
+    rewritten_event->reset(rewritten_mouse_event);
+    rewritten_mouse_event->set_flags(flags);
+#if defined(USE_X11)
+    XEvent* xev = rewritten_mouse_event->native_event();
+    if (xev) {
+      switch (xev->type) {
+        case ButtonPress:
+        case ButtonRelease: {
+          XButtonEvent* xbutton = &(xev->xbutton);
+          UpdateX11EventMask(rewritten_mouse_event->flags(), &xbutton->state);
+          break;
+        }
+        case GenericEvent: {
+          XIDeviceEvent* xievent =
+              static_cast<XIDeviceEvent*>(xev->xcookie.data);
+          CHECK(xievent->evtype == XI_ButtonPress ||
+                xievent->evtype == XI_ButtonRelease);
+          UpdateX11EventMask(
+              rewritten_mouse_event->flags(),
+              reinterpret_cast<unsigned int*>(&xievent->mods.effective));
+          break;
+        }
+        default:
+          NOTREACHED();
+      }
+    }
+#endif
+  }
+  return status;
+}
+
+ui::EventRewriteStatus EventRewriter::RewriteTouchEvent(
+    const ui::TouchEvent& touch_event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
+  int flags = touch_event.flags();
+  RewriteLocatedEvent(touch_event, &flags);
+  if (touch_event.flags() != flags) {
+    status = ui::EVENT_REWRITE_REWRITTEN;
+    ui::TouchEvent* rewritten_touch_event = new ui::TouchEvent(touch_event);
+    rewritten_event->reset(rewritten_touch_event);
+    rewritten_touch_event->set_flags(flags);
+#if defined(USE_X11)
+    XEvent* xev = rewritten_touch_event->native_event();
+    if (xev) {
+      XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
+      if (xievent) {
+        UpdateX11EventMask(
+            rewritten_touch_event->flags(),
+            reinterpret_cast<unsigned int*>(&xievent->mods.effective));
+      }
+    }
+#endif
+  }
+  return status;
+}
+
 void EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
                                         MutableKeyState* state) {
   DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
          key_event.type() == ui::ET_KEY_RELEASED);
 
   // Do nothing if we have just logged in as guest but have not restarted chrome
   // process yet (so we are still on the login screen). In this situations we
   // have no user profile so can not do anything useful.
   // Note that currently, unlike other accounts, when user logs in as guest, we
   // restart chrome process. In future this is to be changed.
@@ skipping 269 matching lines @@
         {ui::VKEY_9, ui::EF_COMMAND_DOWN, ui::VKEY_F9, 0},
         {ui::VKEY_0, ui::EF_COMMAND_DOWN, ui::VKEY_F10, 0},
         {ui::VKEY_OEM_MINUS, ui::EF_COMMAND_DOWN, ui::VKEY_F11, 0},
         {ui::VKEY_OEM_PLUS, ui::EF_COMMAND_DOWN, ui::VKEY_F12, 0}};
     rewritten = RewriteWithKeyboardRemappingsByKeyCode(
         kNumberKeysToFkeys, arraysize(kNumberKeysToFkeys), incoming, state);
   }
 }
 
 void EventRewriter::RewriteLocatedEvent(const ui::Event& event,
-                                        MutableKeyState* state) {
+                                        int* flags) {
   const PrefService* pref_service = GetPrefService();
   if (!pref_service)
     return;
 
   // First, remap modifier masks.
-  state->flags = GetRemappedModifierMasks(*pref_service, event, state->flags);
+  *flags = GetRemappedModifierMasks(*pref_service, event, *flags);
 
 #if defined(USE_X11)
   // TODO(kpschoedel): de-X11 with unified device ids from crbug.com/360377
   XEvent* xevent = event.native_event();
   if (!xevent || xevent->type != GenericEvent)
     return;
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
   if (xievent->evtype != XI_ButtonPress && xievent->evtype != XI_ButtonRelease)
     return;
+  UpdateX11EventMask(*flags,
+                     reinterpret_cast<unsigned int*>(&xievent->mods.effective));
 
   // Then, remap Alt+Button1 to Button3.
   if ((xievent->evtype == XI_ButtonPress ||
        pressed_device_ids_.count(xievent->sourceid)) &&
       (xievent->mods.effective & Mod1Mask) && xievent->detail == Button1) {
-    state->flags &= ~(ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON);
-    state->flags |= ui::EF_RIGHT_MOUSE_BUTTON;
+    *flags &= ~(ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON);
+    *flags |= ui::EF_RIGHT_MOUSE_BUTTON;
     xievent->mods.effective &= ~Mod1Mask;
     xievent->detail = Button3;
     if (xievent->evtype == XI_ButtonRelease) {
       // On the release clear the left button from the existing state and the
       // mods, and set the right button.
       XISetMask(xievent->buttons.mask, Button3);
       XIClearMask(xievent->buttons.mask, Button1);
       xievent->mods.effective &= ~Button1Mask;
       pressed_device_ids_.erase(xievent->sourceid);
     } else {
@@ skipping 63 matching lines @@
 
   XIFreeDeviceInfo(device_info);
 }
 
 void EventRewriter::DeviceRemoved(int device_id) {
   device_id_to_type_.erase(device_id);
 }
 #endif
 
 }  // namespace chromeos