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

ui/aura/window_event_dispatcher.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 "ui/aura/window_event_dispatcher.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/env_input_state_controller.h"
 #include "ui/aura/mus/mus_mouse_location_updater.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #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"
 
 typedef ui::EventDispatchDetails DispatchDetails;
 
 namespace aura {
 
 namespace {
 
@@ skipping 13 matching lines @@
 bool IsEventCandidateForHold(const ui::Event& event) {
   if (event.type() == ui::ET_TOUCH_MOVED)
     return true;
   if (event.type() == ui::ET_MOUSE_DRAGGED)
     return true;
   if (event.IsMouseEvent() && (event.flags() & ui::EF_IS_SYNTHESIZED))
     return true;
   return false;
 }
 
+void ConvertEventLocationToTarget(ui::EventTarget* event_target,
+                                  ui::EventTarget* target,
+                                  ui::Event* event) {
+  if (target != event_target && event->IsLocatedEvent()) {
+    gfx::Point location = event->AsLocatedEvent()->location();
+    gfx::Point root_location = event->AsLocatedEvent()->root_location();
+    Window::ConvertPointToTarget(static_cast<Window*>(event_target),
+                                 static_cast<Window*>(target), &location);
+    Window::ConvertPointToTarget(static_cast<Window*>(event_target),
+                                 static_cast<Window*>(target), &root_location);
+    event->AsLocatedEvent()->set_location(location);
+    event->AsLocatedEvent()->set_root_location(root_location);
+  }
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowEventDispatcher, public:
 
 WindowEventDispatcher::WindowEventDispatcher(WindowTreeHost* host)
     : host_(host),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       event_dispatch_target_(NULL),
       old_dispatch_target_(NULL),
       synthesize_mouse_move_(false),
       move_hold_count_(0),
       dispatching_held_event_(nullptr),
       observer_manager_(this),
       env_controller_(new EnvInputStateController),
+      event_targeter_(new WindowTargeter),
       repost_event_factory_(this),
       held_event_factory_(this) {
   ui::GestureRecognizer::Get()->AddGestureEventHelper(this);
   Env::GetInstance()->AddObserver(this);
   if (Env::GetInstance()->mode() == Env::Mode::MUS)
     mus_mouse_location_updater_ = base::MakeUnique<MusMouseLocationUpdater>();
 }
 
 WindowEventDispatcher::~WindowEventDispatcher() {
   TRACE_EVENT0("shutdown", "WindowEventDispatcher::Destructor");
   Env::GetInstance()->RemoveObserver(this);
   ui::GestureRecognizer::Get()->RemoveGestureEventHelper(this);
 }
 
+ui::EventTargeter* WindowEventDispatcher::GetDefaultEventTargeter() {
+  return event_targeter_.get();
+}
+
 void WindowEventDispatcher::RepostEvent(const ui::LocatedEvent* event) {
   DCHECK(event->type() == ui::ET_MOUSE_PRESSED ||
          event->type() == ui::ET_GESTURE_TAP_DOWN ||
          event->type() == ui::ET_TOUCH_PRESSED);
   // We allow for only one outstanding repostable event. This is used
   // in exiting context menus.  A dropped repost request is allowed.
   if (event->type() == ui::ET_MOUSE_PRESSED) {
     held_repostable_event_.reset(new ui::MouseEvent(
         *event->AsMouseEvent(), static_cast<aura::Window*>(event->target()),
         window()));
@@ skipping 306 matching lines @@
 void WindowEventDispatcher::SetNativeCapture() {
   host_->SetCapture();
 }
 
 void WindowEventDispatcher::ReleaseNativeCapture() {
   host_->ReleaseCapture();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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* event_target = event->target();
+
+  // Mouse events should be dispatched to the window that processed the
+  // mouse-press events (if any).
+  if (event->IsScrollEvent() || event->IsMouseEvent()) {
+    if (mouse_pressed_handler()) {
+      ConvertEventLocationToTarget(event_target, mouse_pressed_handler(),
+                                   event);
+      return mouse_pressed_handler();
+    }
+  }
+
+  // All events should be directed towards the capture window (if any).

[sky, 2017/02/24 21:22:54]

Should this come before the scroll-event/mouse-event check?

[riajiang, 2017/02/27 22:59:30]

If there's a mouse_pressed_handler set then that handler/window would be the
capture window? This is from WindowTargeter::FindTargetInRootWindow (added
TODO).

+  Window* capture_window = client::GetCaptureWindow(window());
+  if (capture_window) {
+    ConvertEventLocationToTarget(event_target, capture_window, event);
+    return capture_window;
+  }
+
+  if (event->IsTouchEvent()) {
+    // Query the gesture-recognizer to find targets for touch events.
+    const ui::TouchEvent& touch = *event->AsTouchEvent();
+    ui::GestureConsumer* consumer =
+        ui::GestureRecognizer::Get()->GetTouchLockedTarget(touch);
+    if (consumer) {
+      ConvertEventLocationToTarget(event_target, static_cast<Window*>(consumer),
+                                   event);
+      return static_cast<Window*>(consumer);
+    }
+    consumer = ui::GestureRecognizer::Get()->GetTargetForLocation(
+        touch.location_f(), touch.source_device_id());
+    if (consumer) {
+      ConvertEventLocationToTarget(event_target, static_cast<Window*>(consumer),
+                                   event);
+      return static_cast<Window*>(consumer);
+    }
+
+    // If the initial touch is outside the root window, target the root.
+    if (!window()->bounds().Contains(touch.location())) {
+      ConvertEventLocationToTarget(event_target, window(), event);
+      return window();
+    }
+  }
+
+  ui::EventTarget* ancestor_with_targeter = event_target;
+  for (ui::EventTarget* ancestor = event_target->GetParentTarget(); ancestor;
+       ancestor = ancestor->GetParentTarget()) {
+    if (ancestor->GetEventTargeter())
+      ancestor_with_targeter = ancestor;
+    if (ancestor == window())
+      break;
+  }
+  ConvertEventLocationToTarget(event_target, ancestor_with_targeter, event);
+  return ancestor_with_targeter;
 }
 
 void WindowEventDispatcher::OnEventProcessingStarted(ui::Event* event) {
   // The held events are already in |window()|'s coordinate system. So it is
   // not necessary to apply the transform to convert from the host's
   // coordinate system to |window()|'s coordinate system.
   if (event->IsLocatedEvent() && !is_dispatched_held_event(*event))
     TransformEventForDeviceScaleFactor(static_cast<ui::LocatedEvent*>(event));
 
   if (mus_mouse_location_updater_)
@@ skipping 439 matching lines @@
   }
 
   // This flag is set depending on the gestures recognized in the call above,
   // and needs to propagate with the forwarded event.
   event->set_may_cause_scrolling(orig_event.may_cause_scrolling());
 
   return PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura