Refactors away method implementations in ui::EventTargeter

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"
+#include "ui/events/event_target_iterator.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) {
+ui::EventTarget* WindowTargeter::FindTargetForLocatedEvent(
+    ui::EventTarget* root,
+    ui::LocatedEvent* 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->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());
+  if (!window->parent()) {
+    Window* target = FindTargetInRootWindow(window, *event);
+    if (target) {
+      window->ConvertEventToTarget(target, event);
+      return target;
     }
-    ignore_result(
-        new_root->GetHost()->event_processor()->OnEventFromSource(event));
-
-    target = NULL;
   }
-  return target;
+  return FindTargetForEventRecursively(window, event);
 }
 
 bool WindowTargeter::SubtreeCanAcceptEvent(
     ui::EventTarget* target,
     const ui::LocatedEvent& event) const {
   aura::Window* window = static_cast<aura::Window*>(target);
   if (!window->IsVisible())
     return false;
   if (window->ignore_events())
     return false;
@@ skipping 12 matching lines @@
 bool WindowTargeter::EventLocationInsideBounds(
     ui::EventTarget* target,
     const ui::LocatedEvent& event) const {
   aura::Window* window = static_cast<aura::Window*>(target);
   gfx::Point point = event.location();
   if (window->parent())
     aura::Window::ConvertPointToTarget(window->parent(), window, &point);
   return gfx::Rect(window->bounds().size()).Contains(point);
 }
 
-ui::EventTarget* WindowTargeter::FindTargetForLocatedEvent(
-    ui::EventTarget* root,
-    ui::LocatedEvent* event) {
+ui::EventTarget* WindowTargeter::FindTargetForEvent(ui::EventTarget* root,
+                                                    ui::Event* event) {
   Window* window = static_cast<Window*>(root);
-  if (!window->parent()) {
-    Window* target = FindTargetInRootWindow(window, *event);
-    if (target) {
-      window->ConvertEventToTarget(target, event);
-      return target;
+  Window* target =
+      event->IsKeyEvent()
+          ? FindTargetForKeyEvent(window, *static_cast<ui::KeyEvent*>(event))
+          : FindTargetForNonKeyEvent(window, event);
+  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 (event->IsLocatedEvent()) {
+      // 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());
     }
+    ignore_result(
+        new_root->GetHost()->event_processor()->OnEventFromSource(event));
+
+    target = NULL;
   }
-  return EventTargeter::FindTargetForLocatedEvent(root, event);
+  return target;
+}
+
+bool WindowTargeter::SubtreeShouldBeExploredForEvent(
+    ui::EventTarget* target,
+    const ui::LocatedEvent& event) {
+  return SubtreeCanAcceptEvent(target, event) &&
+         EventLocationInsideBounds(target, event);
 }
 
 Window* WindowTargeter::FindTargetForKeyEvent(Window* window,
                                               const ui::KeyEvent& key) {
   Window* root_window = window->GetRootWindow();
   client::FocusClient* focus_client = client::GetFocusClient(root_window);
   Window* focused_window = focus_client->GetFocusedWindow();
   if (!focused_window)
     return window;
 
   client::EventClient* event_client = client::GetEventClient(root_window);
   if (event_client &&
       !event_client->CanProcessEventsWithinSubtree(focused_window)) {
     focus_client->FocusWindow(NULL);
     return NULL;
   }
   return focused_window ? focused_window : window;
 }
 
+Window* WindowTargeter::FindTargetForNonKeyEvent(Window* root_window,
+                                                 ui::Event* event) {
+  if (!event->IsLocatedEvent())
+    return root_window;
+  return static_cast<Window*>(FindTargetForLocatedEvent(
+      root_window, static_cast<ui::LocatedEvent*>(event)));
+}
+
 Window* WindowTargeter::FindTargetInRootWindow(Window* root_window,
                                                const ui::LocatedEvent& event) {
   DCHECK_EQ(root_window, root_window->GetRootWindow());
 
   // Mouse events should be dispatched to the window that processed the
   // mouse-press events (if any).
   if (event.IsScrollEvent() || event.IsMouseEvent()) {
     WindowEventDispatcher* dispatcher = root_window->GetHost()->dispatcher();
     if (dispatcher->mouse_pressed_handler())
       return dispatcher->mouse_pressed_handler();
@@ skipping 18 matching lines @@
       return static_cast<Window*>(consumer);
 
     // If the initial touch is outside the root window, target the root.
     if (!root_window->bounds().Contains(event.location()))
       return root_window;
   }
 
   return NULL;
 }
 
+ui::EventTarget* WindowTargeter::FindTargetForEventRecursively(
+    Window* root_window,
+    ui::LocatedEvent* event) {
+  scoped_ptr<ui::EventTargetIterator> iter = root_window->GetChildIterator();
+  if (iter) {
+    ui::EventTarget* target = root_window;
+    for (ui::EventTarget* child = iter->GetNextTarget(); child;
+         child = iter->GetNextTarget()) {
+      WindowTargeter* targeter =
+          static_cast<WindowTargeter*>(child->GetEventTargeter());
+      if (!targeter)
+        targeter = this;
+      if (!targeter->SubtreeShouldBeExploredForEvent(child, *event))
+        continue;
+      target->ConvertEventToTarget(child, event);
+      target = child;
+      ui::EventTarget* child_target =
+          targeter->FindTargetForEvent(child, event);

[tdanderson, 2015/05/13 18:38:25]

Recursively?

[varkha, 2015/05/21 19:11:04]

Not so sure. WindowTargeterTest.ScopedWindowTargeter test fails if I do that and
I could not follow the logic chain that confirms that this is not a semantic
change.

[tdanderson, 2015/05/22 18:29:55]

Seems OK to leave as-is to me, but I think it's worth getting a second opinion
from Sadrul.

[varkha, 2015/05/22 22:18:33]

Yes, the code now reproduces the original flow, not sure if it can be refactored
in such a way that FindTargetForEventRecursively would recursively call itself
rather than just a general FindTargetForEvent.

[sadrul, 2015/05/28 04:48:38]

I think calling FindTargetForEvent is the right thing to do here. It allows the
child window's targeter to customize the behaviour by overriding
FindTargetForEvent if it wants to.

+      if (child_target)
+        return child_target;
+    }
+    target->ConvertEventToTarget(root_window, event);
+  }
+  return root_window->CanAcceptEvent(*event) ? root_window : NULL;
+}
+
 }  // namespace aura