events: Clean up dispatching code for touch-events.

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 643 matching lines @@
 
 bool RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
   if (!target)
     target = this;
   AutoReset<Window*> reset(&event_dispatch_target_, target);
   if (ProcessEvent(target, event) != ui::ER_UNHANDLED)
     return true;
   return false;
 }
 
-ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
+ui::EventResult 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);
-
-  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);
-    if (status != ui::TOUCH_STATUS_UNKNOWN)
-      return status;
-  }
-
-  return ui::TOUCH_STATUS_UNKNOWN;
+  if (!target)
+    target = this;
+  AutoReset<Window*> reset(&event_dispatch_target_, target);
+  return static_cast<ui::EventResult>(ProcessEvent(target, event));
 }
 
 ui::EventResult RootWindow::ProcessGestureEvent(Window* target,
                                                 ui::GestureEvent* event) {
   if (!target)
     target = this;
   AutoReset<Window*> reset(&event_dispatch_target_, target);
   return static_cast<ui::EventResult>(ProcessEvent(target, event));
 }
 
@@ skipping 193 matching lines @@
       break;
 
     default:
       break;
   }
   float scale = ui::GetDeviceScaleFactor(layer());
   ui::Transform transform = layer()->transform();
   transform.ConcatScale(scale, scale);
   event->UpdateForRootTransform(transform);
   bool handled = false;
-  ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
+  ui::EventResult result = ui::ER_UNHANDLED;
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTouchLockedTarget(event));
     if (!target) {
       target = ConsumerToWindow(
           gesture_recognizer_->GetTargetForLocation(event->location()));
     }
   }
 
   if (!target && !bounds().Contains(event->location())) {
     // If the initial touch is outside the root window, target the root.
     target = this;
-    status = ProcessTouchEvent(target, event);
-    CHECK_EQ(ui::TOUCH_STATUS_UNKNOWN, status);
+    result = ProcessTouchEvent(target, event);
+    CHECK_EQ(ui::ER_UNHANDLED, result);
   } else {
     // We only come here when the first contact was within the root window.
     if (!target) {
       target = GetEventHandlerForPoint(event->location());
       if (!target)
         return false;
     }
 
     ui::TouchEvent translated_event(
         *event, static_cast<Window*>(this), target);
-    status = ProcessTouchEvent(target, &translated_event);
-    handled = status != ui::TOUCH_STATUS_UNKNOWN;
+    result = ProcessTouchEvent(target, &translated_event);
+    handled = result != ui::ER_UNHANDLED;
 
-    if (status == ui::TOUCH_STATUS_QUEUED ||
-        status == ui::TOUCH_STATUS_QUEUED_END) {
+    if (result & ui::ER_ASYNC) {
       gesture_recognizer_->QueueTouchEventForGesture(target, *event);
       return true;
     }
   }
 
   // Get the list of GestureEvents from GestureRecognizer.
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
   gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
-      *event, status, target));
+      *event, result, target));
 
   return ProcessGestures(gestures.get()) ? true : handled;
 }
 
 void RootWindow::OnHostLostCapture() {
   Window* capture_window = client::GetCaptureWindow(this);
   if (capture_window && capture_window->GetRootWindow() == this)
     capture_window->ReleaseCapture();
 }
 
@@ skipping 132 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura