aura: Make sure redirected events have the correct location.

ui/aura/window_targeter.cc

 // Copyright (c) 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 "ui/aura/window_targeter.h"
 
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event_target.h"
 
 namespace aura {
 
+namespace {
+
+bool IsLocatedEvent(const ui::Event& event) {
+  return event.IsMouseEvent() || event.IsTouchEvent() ||
+         event.IsScrollEvent() || event.IsGestureEvent();
+}
+
+}  // namespace
+
 WindowTargeter::WindowTargeter() {}
 WindowTargeter::~WindowTargeter() {}
 
 ui::EventTarget* WindowTargeter::FindTargetForEvent(ui::EventTarget* root,
                                                     ui::Event* event) {
   Window* window = static_cast<Window*>(root);
   Window* target = event->IsKeyEvent() ?
       FindTargetForKeyEvent(window, *static_cast<ui::KeyEvent*>(event)) :
       static_cast<Window*>(EventTargeter::FindTargetForEvent(root, event));
-  if (target && !window->parent()) {
-    // |window| is the root window.
-    if (!window->Contains(target)) {
-      // |target| is not a descendent of |window|. So do not allow dispatching
-      // from here. Instead, dispatch the event through the
-      // WindowEventDispatcher that owns |target|.
-      ui::EventDispatchDetails details ALLOW_UNUSED =
-          target->GetHost()->event_processor()->OnEventFromSource(event);
-      target = NULL;
+  if (target && !window->parent() && !window->Contains(target)) {
+    // |window| is the root window, but |target| is not a descendent of
+    // |window|. So do not allow dispatching from here. Instead, dispatch the
+    // event through the WindowEventDispatcher that owns |target|.
+    aura::Window* new_root = target->GetRootWindow();
+    if (IsLocatedEvent(*event)) {
+      // The event has been transformed to be in |target|'s coordinate system.
+      // But dispatching the event through the EventProcessor requires the event
+      // to be in the host's coordinate system. So, convert the event to be in
+      // the root's coordinate space, and then to the host's coordinate space by
+      // applying the host's transform.
+      ui::LocatedEvent* located_event = static_cast<ui::LocatedEvent*>(event);
+      located_event->ConvertLocationToTarget(target, new_root);
+      located_event->UpdateForRootTransform(
+          new_root->GetHost()->GetRootTransform());
     }
+    ui::EventDispatchDetails details ALLOW_UNUSED =
+        new_root->GetHost()->event_processor()->OnEventFromSource(event);
+    target = NULL;
   }
   return target;
 }
 
 bool WindowTargeter::SubtreeCanAcceptEvent(
     ui::EventTarget* target,
     const ui::LocatedEvent& event) const {
   aura::Window* window = static_cast<aura::Window*>(target);
   if (!window->IsVisible())
     return false;
@@ skipping 88 matching lines @@
 
     // If the initial touch is outside the root window, target the root.
     if (!root_window->bounds().Contains(event.location()))
       return root_window;
   }
 
   return NULL;
 }
 
 }  // namespace aura