aura: Start converting event-filters into event-handlers.

ui/aura/root_window.cc

 // Copyright (c) 2012 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/root_window.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 46 matching lines @@
 }
 
 typedef std::vector<EventFilter*> EventFilters;
 
 void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
   while (target) {
     if (target->event_filter())
       filters->push_back(target->event_filter());
     target = target->parent();
   }
-  if (Env::GetInstance()->event_filter())
-    filters->push_back(Env::GetInstance()->event_filter());
 }
 
 float GetDeviceScaleFactorFromDisplay(const Window* window) {
   DisplayManager* display_manager = Env::GetInstance()->display_manager();
   return display_manager->GetDisplayNearestWindow(window).device_scale_factor();
 }
 
 Window* ConsumerToWindow(ui::GestureConsumer* consumer) {
   return consumer && !consumer->ignores_events() ?
       static_cast<Window*>(consumer) : NULL;
@@ skipping 390 matching lines @@
 void RootWindow::SetTransform(const ui::Transform& transform) {
   Window::SetTransform(transform);
 
   // If the layer is not animating, then we need to update the host size
   // immediately.
   if (!layer()->GetAnimator()->is_animating())
     OnHostResized(host_->GetBounds().size());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// RootWindow, ui::EventTarget implementation:
+
+ui::EventTarget* RootWindow::GetParentTarget() {
+  return Env::GetInstance();
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::CompositorDelegate implementation:
 
 void RootWindow::ScheduleDraw() {
   if (compositor_lock_) {
     draw_on_compositor_unlock_ = true;
   } else if (!defer_draw_scheduling_) {
     defer_draw_scheduling_ = true;
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RootWindow::Draw, schedule_paint_factory_.GetWeakPtr()));
@@ skipping 168 matching lines @@
 }
 
 ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
                                               ui::TouchEvent* event) {
   if (ProcessEvent(NULL, event) != ui::ER_UNHANDLED)
     return ui::TOUCH_STATUS_CONTINUE;
 
   if (!target->IsVisible())
     return ui::TOUCH_STATUS_UNKNOWN;
 
+  ui::Event::DispatcherApi dispatch_helper(event);
+  dispatch_helper.set_target(target);
+
+  // It is necessary to dispatch the event to the event-handlers on env first.
+  // TODO(sad): Fix touch-event handling so it can use the same
+  // event-dispatching code used for other events.
+  ui::EventTarget::DispatcherApi dispatch_target_helper(Env::GetInstance());
+  const ui::EventHandlerList& pre_target =
+      dispatch_target_helper.pre_target_list();
+  for (ui::EventHandlerList::const_iterator iter = pre_target.begin();
+      iter != pre_target.end(); ++iter) {
+    ui::TouchStatus status = (*iter)->OnTouchEvent(event);
+    if (status != ui::TOUCH_STATUS_UNKNOWN)
+      return status;
+  }
+
   EventFilters filters;
   if (target == this)
     GetEventFiltersToNotify(target, &filters);
   else
     GetEventFiltersToNotify(target->parent(), &filters);
 
   // |target| can be deleted by any of the handlers below.
   WindowTracker tracker;
   tracker.Add(target);
 
-  ui::Event::DispatcherApi dispatcher(event);
-  dispatcher.set_target(target);
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
        it != rend; ++it) {
     ui::TouchStatus status = (*it)->PreHandleTouchEvent(target, event);
     if (status != ui::TOUCH_STATUS_UNKNOWN)
       return status;
   }
 
   if (tracker.Contains(target) && target->delegate()) {
     ui::TouchStatus status = target->delegate()->OnTouchEvent(event);
@@ skipping 95 matching lines @@
   if (attached->IsVisible() &&
       attached->ContainsPointInRoot(GetLastMouseLocationInRoot()))
     PostMouseMoveEventAfterWindowChange();
 }
 
 bool RootWindow::CanDispatchToTarget(ui::EventTarget* target) {
   return event_dispatch_target_ == target;
 }
 
 void RootWindow::ProcessPreTargetList(ui::EventHandlerList* list) {
-  if (Env::GetInstance()->event_filter())
-    list->insert(list->begin(), Env::GetInstance()->event_filter());
 }
 
 void RootWindow::ProcessPostTargetList(ui::EventHandlerList* list) {

[Ben Goodger (Google), 2012/09/21 18:09:18]

seems like you could also nix this api now, since this was all it was used for.

[sadrul, 2012/09/21 19:05:36]

Good point. But I am going to keep this for now since there is a test that uses
this API to make sure the handlers receive events in the correct phase. The test
can probably be made to work without this, though. I will clean up in a follow
up CL.

-  // TODO(sad):
 }
 
 bool RootWindow::DispatchLongPressGestureEvent(ui::GestureEvent* event) {
   return DispatchGestureEvent(event);
 }
 
 bool RootWindow::DispatchCancelTouchEvent(ui::TouchEvent* event) {
   return OnHostTouchEvent(event);
 }
 
@@ skipping 282 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura