Sync ui/events to chromium @ https://codereview.chromium.org/1210203002

services/window_manager/view_targeter.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 "services/window_manager/view_targeter.h"
 
 #include "services/window_manager/capture_controller.h"
 #include "services/window_manager/focus_controller.h"
 #include "services/window_manager/view_target.h"
+#include "ui/events/event_target_iterator.h"
 
 namespace window_manager {
 
 ViewTargeter::ViewTargeter() {}
 
 ViewTargeter::~ViewTargeter() {}
 
 ui::EventTarget* ViewTargeter::FindTargetForEvent(ui::EventTarget* root,
                                                   ui::Event* event) {
   ViewTarget* view = static_cast<ViewTarget*>(root);
-  ViewTarget* target =
-      event->IsKeyEvent()
-          ? FindTargetForKeyEvent(view, *static_cast<ui::KeyEvent*>(event))
-          : static_cast<ViewTarget*>(
-                EventTargeter::FindTargetForEvent(root, event));
+  ViewTarget* target;
+  if (event->IsKeyEvent()) {
+    target = FindTargetForKeyEvent(view, *static_cast<ui::KeyEvent*>(event));
+  } else if (event->IsMouseEvent() ||
+      event->IsScrollEvent() ||
+      event->IsTouchEvent() ||
+      event->IsGestureEvent()) {
+    target = static_cast<ViewTarget*>(FindTargetForLocatedEvent(
+      root, static_cast<ui::LocatedEvent*>(event)));
+  } else {
+    target = static_cast<ViewTarget*>(root);
+  }
 
   // TODO(erg): The aura version of this method does a lot of work to handle
   // dispatching to a target that isn't a child of |view|. For now, punt on
   // this.
   DCHECK_EQ(view->GetRoot(), target->GetRoot());
 
   return target;
 }
 
+ui::EventTarget* ViewTargeter::FindNextBestTarget(
+  ui::EventTarget* previous_target, ui::Event* event) {
+  return nullptr;
+}
+
 ui::EventTarget* ViewTargeter::FindTargetForLocatedEvent(
     ui::EventTarget* root,
     ui::LocatedEvent* event) {
   ViewTarget* view = static_cast<ViewTarget*>(root);
   if (!view->HasParent()) {
     ViewTarget* target = FindTargetInRootView(view, *event);
     if (target) {
       view->ConvertEventToTarget(target, event);
       return target;
     }
   }
-  return EventTargeter::FindTargetForLocatedEvent(view, event);
+  scoped_ptr<ui::EventTargetIterator> iter = root->GetChildIterator();
+  if (iter) {
+    ui::EventTarget* target = root;
+    for (ui::EventTarget* child = iter->GetNextTarget(); child;
+         child = iter->GetNextTarget()) {
+      ViewTargeter* targeter = static_cast<ViewTargeter*>(
+        child->GetEventTargeter());
+      if (!targeter)
+        targeter = this;
+      if (!targeter->SubtreeShouldBeExploredForEvent(child, *event))
+        continue;
+      target->ConvertEventToTarget(child, event);
+      target = child;
+      ui::EventTarget* child_target =
+          targeter->FindTargetForLocatedEvent(child, event);
+      if (child_target)
+        return child_target;
+    }
+    target->ConvertEventToTarget(root, event);
+  }
+  return root->CanAcceptEvent(*event) ? root : NULL;
+}
+
+bool ViewTargeter::SubtreeShouldBeExploredForEvent(
+  ui::EventTarget* target, const ui::LocatedEvent& event) {
+  return SubtreeCanAcceptEvent(target, event) &&
+         EventLocationInsideBounds(target, event);
 }
 
 bool ViewTargeter::SubtreeCanAcceptEvent(ui::EventTarget* target,
                                          const ui::LocatedEvent& event) const {
   ViewTarget* view = static_cast<ViewTarget*>(target);
 
   if (!view->IsVisible())
     return false;
 
   // TODO(erg): We may need to keep track of the parent on ViewTarget, because
@@ skipping 44 matching lines @@
       return ViewTarget::TargetFromView(capture_view);
   }
 
   // TODO(erg): There's a whole bunch of junk about handling touch events
   // here. Handle later.
 
   return nullptr;
 }
 
 }  // namespace window_manager