Fix sticky keys crash when handling synthetic events without a native event.

ash/sticky_keys/sticky_keys_controller.cc

 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #undef RootWindow
@@ skipping 51 matching lines @@
 void StickyKeysHandlerDelegateImpl::DispatchKeyEvent(ui::KeyEvent* event,
                                                      aura::Window* target) {
   DispatchEvent(event, target);
 }
 
 void StickyKeysHandlerDelegateImpl::DispatchMouseEvent(ui::MouseEvent* event,
                                                        aura::Window* target) {
   DCHECK(target);
   // We need to send a new, untransformed mouse event to the host.
   if (event->IsMouseWheelEvent()) {
-    ui::MouseWheelEvent new_event(event->native_event());
+    aura::Window* source = static_cast<aura::Window*>(event->target());
+    ui::MouseWheelEvent new_event(*static_cast<ui::MouseWheelEvent*>(event),
+                                  source,
+                                  source->GetRootWindow());
+    // Transform the location back to host coordinates before dispatching.
+    new_event.UpdateForRootTransform(source->GetHost()->GetRootTransform());
     DispatchEvent(&new_event, target);
   } else {
-    ui::MouseEvent new_event(event->native_event());
+    aura::Window* source = static_cast<aura::Window*>(event->target());
+    ui::MouseEvent new_event(*event, source, source->GetRootWindow());
+    // Transform the location back to host coordinates before dispatching.
+    new_event.UpdateForRootTransform(source->GetHost()->GetRootTransform());
     DispatchEvent(&new_event, target);
   }
 }
 
 void StickyKeysHandlerDelegateImpl::DispatchScrollEvent(
     ui::ScrollEvent* event,
     aura::Window* target)  {
   DispatchEvent(event, target);
 }
 
@@ skipping 387 matching lines @@
   event->set_flags(event->flags() | modifier_flag_);
   event->set_character(ui::GetCharacterFromKeyCode(event->key_code(),
                                                    event->flags()));
   event->NormalizeFlags();
 }
 
 void StickyKeysHandler::AppendModifier(ui::MouseEvent* event) {
 #if defined(USE_X11)
   // The native mouse event can either be a classic X button event or an
   // XInput2 button event.
   XEvent* xev = event->native_event();

[sadrul, 2014/04/07 22:32:10]

Since you are creating the mouse-event directly from the ui::MouseEvent, do you
need to mutate the X event anymore?

[Tim Song, 2014/04/07 22:53:59]

The X event modification was also needed for proper interaction with the
EventRewriter, but with the refactoring you're doing, I think we don't have to
modify the X event any more.

This CL does need to be merged though, so I'll look into removing this code in
another CL.

[sadrul, 2014/04/08 03:01:34]

Perhaps the X-event mutation isn't needed in the other AppendModifer()s too.
Please look into it when you get a chance. Thanks!

   if (xev) {
     switch (xev->type) {
       case ButtonPress:
       case ButtonRelease: {
         XButtonEvent* xkey = &(xev->xbutton);
         AppendNativeEventMask(&xkey->state);
         break;
       }
       case GenericEvent: {
         XIDeviceEvent* xievent =
             static_cast<XIDeviceEvent*>(xev->xcookie.data);
         CHECK(xievent->evtype == XI_ButtonPress ||
               xievent->evtype == XI_ButtonRelease);
         AppendNativeEventMask(
             reinterpret_cast<unsigned int*>(&xievent->mods.effective));
         break;
       }
       default:
         NOTREACHED();
     }
   }
 #elif defined(USE_OZONE)
   NOTIMPLEMENTED() << "Modifier key is not handled";
 #endif
   event->set_flags(event->flags() | modifier_flag_);

[sadrul, 2014/04/07 22:32:10]

Since this is not the event you dispatch, do you need to change the flags here?

[Tim Song, 2014/04/07 22:53:59]

There are two sticky key states, normal (press modifier key once) and locked
(press modifier key twice). In the normal case, we redispatch a new event;
however, in the locked case, we modify the event directly and let it continue
with the dispatch. The reason for this is that we need to dispatch the modifier
release event in the proper sequence immediately after the modified event.

 }
 
 void StickyKeysHandler::AppendModifier(ui::ScrollEvent* event) {
 #if defined(USE_X11)
   XEvent* xev = event->native_event();
   if (xev) {
     XIDeviceEvent* xievent =
         static_cast<XIDeviceEvent*>(xev->xcookie.data);
     if (xievent) {
       AppendNativeEventMask(reinterpret_cast<unsigned int*>(
           &xievent->mods.effective));
     }
   }
 #elif defined(USE_OZONE)
   NOTIMPLEMENTED() << "Modifier key is not handled";
 #endif
   event->set_flags(event->flags() | modifier_flag_);
 }
 
 }  // namespace ash