aura: Use EventPrcessor interface for dispatching 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/bind.h"
 #include "base/command_line.h"
@@ skipping 62 matching lines @@
 RootWindowHost* CreateHost(RootWindow* root_window,
                            const RootWindow::CreateParams& params) {
   RootWindowHost* host = params.host ?
       params.host : RootWindowHost::Create(params.initial_bounds);
   host->set_delegate(root_window);
   return host;
 }
 
 bool IsUsingEventProcessorForDispatch(const ui::Event& event) {
   return event.IsKeyEvent() ||
-         event.IsScrollEvent();
+         event.IsScrollEvent() ||
+         event.IsTouchEvent();
+}
+
+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;
 }
 
 }  // namespace
 
 RootWindow::CreateParams::CreateParams(const gfx::Rect& a_initial_bounds)
     : initial_bounds(a_initial_bounds),
       host(NULL) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 480 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::EventDispatcherDelegate implementation:
 
 bool RootWindow::CanDispatchToTarget(ui::EventTarget* target) {
   return event_dispatch_target_ == target;
 }
 
 ui::EventDispatchDetails RootWindow::PreDispatchEvent(ui::EventTarget* target,
                                                       ui::Event* event) {
   if (!dispatching_held_event_ && IsUsingEventProcessorForDispatch(*event)) {
-    DispatchDetails details = DispatchHeldEvents();
-    if (details.dispatcher_destroyed || details.target_destroyed)
-      return details;
+    if (!move_hold_count_ || !IsEventCandidateForHold(*event)) {
+      if (IsEventCandidateForHold(*event))
+        held_move_event_.reset();
+      DispatchDetails details = DispatchHeldEvents();
+      if (details.dispatcher_destroyed || details.target_destroyed)
+        return details;
+    }
 
     Window* target_window = static_cast<Window*>(target);
     if (event->IsScrollEvent()) {
       PreDispatchLocatedEvent(target_window,
                               static_cast<ui::ScrollEvent*>(event));
+    } else if (event->IsTouchEvent()) {
+      PreDispatchTouchEvent(target_window, static_cast<ui::TouchEvent*>(event));
     }
   }
   old_dispatch_target_ = event_dispatch_target_;
   event_dispatch_target_ = static_cast<Window*>(target);
   return DispatchDetails();
 }
 
 ui::EventDispatchDetails RootWindow::PostDispatchEvent(ui::EventTarget* target,
                                                        const ui::Event& event) {
   DispatchDetails details;
   if (target != event_dispatch_target_)
     details.target_destroyed = true;
   event_dispatch_target_ = old_dispatch_target_;
   old_dispatch_target_ = NULL;
 #ifndef NDEBUG
   DCHECK(!event_dispatch_target_ || window()->Contains(event_dispatch_target_));
 #endif
+
+  if (event.IsTouchEvent() && !details.target_destroyed) {
+    ui::TouchEvent orig_event(static_cast<const ui::TouchEvent&>(event),
+                              static_cast<Window*>(event.target()), window());
+    // Get the list of GestureEvents from GestureRecognizer.
+    scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
+    gestures.reset(ui::GestureRecognizer::Get()->
+        ProcessTouchEventForGesture(orig_event, event.result(),
+                                    static_cast<Window*>(target)));
+    return ProcessGestures(gestures.get());
+  }
+
   return details;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::GestureEventHelper implementation:
 
 bool RootWindow::CanDispatchToConsumer(ui::GestureConsumer* consumer) {
   Window* consumer_window = ConsumerToWindow(consumer);;
   return (consumer_window && consumer_window->GetRootWindow() == window());
 }
@@ skipping 38 matching lines @@
 }
 
 bool RootWindow::OnHostScrollEvent(ui::ScrollEvent* event) {
   DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
     event->SetHandled();
   return event->handled();
 }
 
 bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
-  if ((event->type() == ui::ET_TOUCH_MOVED)) {
-    if (move_hold_count_) {
-      Window* null_window = static_cast<Window*>(NULL);
-      held_move_event_.reset(
-          new ui::TouchEvent(*event, null_window, null_window));
-      return true;
-    } else {
-      // We may have a held event for a period between the time move_hold_count_
-      // fell to 0 and the DispatchHeldEvents executes. Since we're going to
-      // dispatch the new event directly below, we can reset the old one.
-      held_move_event_.reset();
-    }
-  }
-  DispatchDetails details = DispatchHeldEvents();
+  DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
-    return false;
-  details = DispatchTouchEventImpl(event);
-  if (details.dispatcher_destroyed)
-    return true;
+    event->SetHandled();
   return event->handled();
 }
 
 void RootWindow::OnHostCancelMode() {
   ui::CancelModeEvent event;
   Window* focused_window = client::GetFocusClient(window())->GetFocusedWindow();
   DispatchDetails details =
       DispatchEvent(focused_window ? focused_window : window(), &event);
   if (details.dispatcher_destroyed)
     return;
@@ skipping 43 matching lines @@
 
 ui::EventProcessor* RootWindow::GetEventProcessor() {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
 ui::EventDispatchDetails RootWindow::OnHostMouseEventImpl(
     ui::MouseEvent* event) {
-  if (event->type() == ui::ET_MOUSE_DRAGGED ||
-      (event->flags() & ui::EF_IS_SYNTHESIZED)) {
+  if (IsEventCandidateForHold(*event)) {
     if (move_hold_count_) {
       Window* null_window = static_cast<Window*>(NULL);
       held_move_event_.reset(
           new ui::MouseEvent(*event, null_window, null_window));
       event->SetHandled();
       return DispatchDetails();
     } else {
       // We may have a held event for a period between the time move_hold_count_
       // fell to 0 and the DispatchHeldEvents executes. Since we're going to
       // dispatch the new event directly below, we can reset the old one.
@@ skipping 109 matching lines @@
   }
   if (target) {
     event->ConvertLocationToTarget(window(), target);
     if (IsNonClientLocation(target, event->location()))
       event->set_flags(event->flags() | ui::EF_IS_NON_CLIENT);
     return DispatchEvent(target, event);
   }
   return DispatchDetails();
 }
 
-ui::EventDispatchDetails RootWindow::DispatchTouchEventImpl(
-    ui::TouchEvent* event) {
-  switch (event->type()) {
-    case ui::ET_TOUCH_PRESSED:
-      touch_ids_down_ |= (1 << event->touch_id());
-      Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
-      break;
-
-      // Handle ET_TOUCH_CANCELLED only if it has a native event.
-    case ui::ET_TOUCH_CANCELLED:
-      if (!event->HasNativeEvent())
-        break;
-      // fallthrough
-    case ui::ET_TOUCH_RELEASED:
-      touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
-            (1 << event->touch_id());
-      Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
-      break;
-
-    default:
-      break;
-  }
-  TransformEventForDeviceScaleFactor(event);
-  Window* target = client::GetCaptureWindow(window());
-  if (!target) {
-    target = ConsumerToWindow(
-        ui::GestureRecognizer::Get()->GetTouchLockedTarget(*event));
-    if (!target) {
-      target = ConsumerToWindow(ui::GestureRecognizer::Get()->
-          GetTargetForLocation(event->location()));
-    }
-  }
-
-  // The gesture recognizer processes touch events in the system coordinates. So
-  // keep a copy of the touch event here before possibly converting the event to
-  // a window's local coordinate system.
-  ui::TouchEvent event_for_gr(*event);
-
-  ui::EventResult result = ui::ER_UNHANDLED;
-  if (!target && !window()->bounds().Contains(event->location())) {
-    // If the initial touch is outside the root window, target the root.
-    target = window();
-    DispatchDetails details = DispatchEvent(target ? target : NULL, event);
-    if (details.dispatcher_destroyed)
-      return details;
-    result = event->result();
-  } else {
-    // We only come here when the first contact was within the root window.
-    if (!target) {
-      target = window()->GetEventHandlerForPoint(event->location());
-      if (!target)
-        return DispatchDetails();
-    }
-
-    event->ConvertLocationToTarget(window(), target);
-    DispatchDetails details = DispatchEvent(target, event);
-    if (details.dispatcher_destroyed)
-      return details;
-    result = event->result();
-  }
-
-  // Get the list of GestureEvents from GestureRecognizer.
-  scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-  gestures.reset(ui::GestureRecognizer::Get()->
-      ProcessTouchEventForGesture(event_for_gr, result, target));
-
-  return ProcessGestures(gestures.get());
-}
-
 ui::EventDispatchDetails RootWindow::DispatchHeldEvents() {
   if (!held_repostable_event_ && !held_move_event_)
     return DispatchDetails();
 
   CHECK(!dispatching_held_event_);
   dispatching_held_event_ = true;
 
   DispatchDetails dispatch_details;
   if (held_repostable_event_) {
     if (held_repostable_event_->type() == ui::ET_MOUSE_PRESSED) {
@@ skipping 11 matching lines @@
   if (held_move_event_ && held_move_event_->IsMouseEvent()) {
     // If a mouse move has been synthesized, the target location is suspect,
     // so drop the held event.
     if (!synthesize_mouse_move_) {
       dispatch_details = DispatchMouseEventImpl(
           static_cast<ui::MouseEvent*>(held_move_event_.get()));
     }
     if (!dispatch_details.dispatcher_destroyed)
       held_move_event_.reset();
   } else if (held_move_event_ && held_move_event_->IsTouchEvent()) {
-    dispatch_details = DispatchTouchEventImpl(
+    dispatch_details = OnEventFromSource(
         static_cast<ui::TouchEvent*>(held_move_event_.get()));
     if (!dispatch_details.dispatcher_destroyed)
       held_move_event_.reset();
   }
 
   if (!dispatch_details.dispatcher_destroyed)
     dispatching_held_event_ = false;
   return dispatch_details;
 }
 
@@ skipping 38 matching lines @@
   if (IsNonClientLocation(target, event->location()))
     flags |= ui::EF_IS_NON_CLIENT;
   event->set_flags(flags);
 
   if (!dispatching_held_event_) {
     SetLastMouseLocation(window(), event->location());
     synthesize_mouse_move_ = false;
   }
 }
 
+void RootWindow::PreDispatchTouchEvent(Window* target,
+                                       ui::TouchEvent* event) {
+  switch (event->type()) {
+    case ui::ET_TOUCH_PRESSED:
+      touch_ids_down_ |= (1 << event->touch_id());
+      Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
+      break;
+
+      // Handle ET_TOUCH_CANCELLED only if it has a native event.
+    case ui::ET_TOUCH_CANCELLED:
+      if (!event->HasNativeEvent())
+        break;
+      // fallthrough
+    case ui::ET_TOUCH_RELEASED:
+      touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
+            (1 << event->touch_id());
+      Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
+      break;
+
+    case ui::ET_TOUCH_MOVED:
+      if (move_hold_count_) {
+        held_move_event_.reset(new ui::TouchEvent(*event));
+        event->SetHandled();
+        return;
+      }
+      break;
+
+    default:
+      NOTREACHED();
+      break;
+  }
+  PreDispatchLocatedEvent(target, event);
+}
+
 }  // namespace aura