Avoid two targeting phases in aura client-lib and EventProcessor.

ui/aura/window_event_dispatcher.cc

Index: ui/aura/window_event_dispatcher.cc
diff --git a/ui/aura/window_event_dispatcher.cc b/ui/aura/window_event_dispatcher.cc
index 6cd3c43e2dad9addd866098702afd9b64af79343..9dfb2e6238b0104f6bcf017559b8987e24d5cebf 100644
--- a/ui/aura/window_event_dispatcher.cc
+++ b/ui/aura/window_event_dispatcher.cc
@@ -27,6 +27,7 @@
 #include "ui/base/hit_test.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/events/event.h"
+#include "ui/events/event_targeter.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/events/gestures/gesture_types.h"
@@ -80,8 +81,10 @@ WindowEventDispatcher::WindowEventDispatcher(WindowTreeHost* host)
       held_event_factory_(this) {
   ui::GestureRecognizer::Get()->AddGestureEventHelper(this);
   Env::GetInstance()->AddObserver(this);
-  if (Env::GetInstance()->mode() == Env::Mode::MUS)
+  if (Env::GetInstance()->mode() == Env::Mode::MUS) {
     mus_mouse_location_updater_ = base::MakeUnique<MusMouseLocationUpdater>();
+    event_targeter_ = base::MakeUnique<WindowTargeter>();
+  }
 }
 
 WindowEventDispatcher::~WindowEventDispatcher() {
@@ -416,8 +419,40 @@ void WindowEventDispatcher::ReleaseNativeCapture() {
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, ui::EventProcessor implementation:
-ui::EventTarget* WindowEventDispatcher::GetRootTarget() {
-  return window();
+ui::EventTarget* WindowEventDispatcher::GetRootForEvent(ui::Event* event) {
+  if (Env::GetInstance()->mode() == Env::Mode::LOCAL)
+    return window();
+
+  if (!event->target())
+    return window();
+
+  ui::EventTarget* target = event->target();

[sky, 2017/02/15 20:47:17]

Using ui::EventTarget rather the Window makes this code slightly more confusing.
Given we know the target is a window, can you use Window* here rather than
ui::EventTarget? This means you won't need the casts below.

[riajiang, 2017/02/16 00:34:08]

This function returns ui::EventTarget so I think maybe we can keep using
EventTarget and only cast when it's Window related functions
(Window::ConvertPointToTarget)? We also want to use GetEventTargeter and
GetParentTarget for the EventTarget which would require a cast if it's a Window?

[sky, 2017/02/16 01:03:02]

Ugh! This is one of those places made painful by making the implementation of
the interface private. I would find this code easier to read if it were:

for (aura::Window* ancestor = target->parent(); ancestor; ancestor =
ancestor->parent()) {
*  if (ancestor->GetEventTarget()) ...
}

But * fails because the implementation of GetEventTarget is private.

This is made more awkward because you compare ancestor_with_targeter (an
EventTarger) to window() (an aura::Window). ui::EventTarget *has* to be the
aura::Window.

*SIGH*

Ok, leave what you have.

+  ui::EventTarget* ancestor_with_targeter = target;
+  for (ui::EventTarget* ancestor = target->GetParentTarget(); ancestor;
+       ancestor = ancestor->GetParentTarget()) {
+    if (ancestor->GetEventTargeter())
+      ancestor_with_targeter = ancestor;
+    if (ancestor == window())

[sky, 2017/02/16 01:03:02]

Is this check really necessary?

[riajiang, 2017/02/16 19:10:35]

Because GetParentTarget() will go all the way up to ash::Shell and aura::Env
(which have NOTREACHED in GetEventTargeter) but we only wanted to walk up to the
root widow?

+      break;
+  }
+
+  if (ancestor_with_targeter != target && event->IsLocatedEvent()) {
+    gfx::Point location = event->AsLocatedEvent()->location();
+    gfx::Point root_location = event->AsLocatedEvent()->root_location();
+    Window::ConvertPointToTarget(static_cast<Window*>(target),
+                                 static_cast<Window*>(ancestor_with_targeter),
+                                 &location);
+    Window::ConvertPointToTarget(static_cast<Window*>(target),
+                                 static_cast<Window*>(ancestor_with_targeter),
+                                 &root_location);
+    event->AsLocatedEvent()->set_location(location);
+    event->AsLocatedEvent()->set_root_location(root_location);
+  }
+  return ancestor_with_targeter;
+}
+
+ui::EventTargeter* WindowEventDispatcher::GetDefaultEventTargeter() {
+  return event_targeter_.get();
 }
 
 void WindowEventDispatcher::OnEventProcessingStarted(ui::Event* event) {