Eager Gesture Recognizer (WIP)

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 104 matching lines @@
   prop_.reset(new ui::ViewProp(host_->GetAcceleratedWidget(),
                                kRootWindowForAcceleratedWidget,
                                this));
   ui::GestureRecognizer::Get()->AddGestureEventHelper(this);
 }
 
 RootWindow::~RootWindow() {
   TRACE_EVENT0("shutdown", "RootWindow::Destructor");
 
   ui::GestureRecognizer::Get()->RemoveGestureEventHelper(this);
+  STLDeleteValues(&gesture_event_queues_);
 
   // An observer may have been added by an animation on the RootWindow.
   window()->layer()->GetAnimator()->RemoveObserver(this);
 
   // Destroy child windows while we're still valid. This is also done by
   // ~Window, but by that time any calls to virtual methods overriden here (such
   // as GetRootWindow()) result in Window's implementation. By destroying here
   // we ensure GetRootWindow() still returns this.
   window()->RemoveOrDestroyChildren();
 
@@ skipping 211 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void RootWindow::RemoveRootWindowObserver(RootWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void RootWindow::ProcessedTouchEvent(ui::TouchEvent* event,
                                      Window* window,
                                      ui::EventResult result) {
-  scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
-  gestures.reset(ui::GestureRecognizer::Get()->
-      ProcessTouchEventForGesture(*event, result, window));
-  DispatchDetails details = ProcessGestures(gestures.get());
-  if (details.dispatcher_destroyed)
-    return;
+  gesture_event_queues_[window]->OnTouchEventAck(*event, result);
 }
 
 void RootWindow::HoldPointerMoves() {
   if (!move_hold_count_)
     held_event_factory_.InvalidateWeakPtrs();
   ++move_hold_count_;
   TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::HoldPointerMoves", this);
 }
 
 void RootWindow::ReleasePointerMoves() {
@@ skipping 118 matching lines @@
     mouse_pressed_handler_ = NULL;
   if (invisible->Contains(mouse_moved_handler_))
     mouse_moved_handler_ = NULL;
 
   CleanupGestureState(invisible);
 }
 
 void RootWindow::CleanupGestureState(Window* window) {
   ui::GestureRecognizer::Get()->CancelActiveTouches(window);
   ui::GestureRecognizer::Get()->CleanupStateForConsumer(window);
+  gesture_event_queues_.erase(window);
   const Window::Windows& windows = window->children();
   for (Window::Windows::const_iterator iter = windows.begin();
       iter != windows.end();
       ++iter) {
     CleanupGestureState(*iter);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, aura::client::CaptureDelegate implementation:
@@ skipping 100 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::GestureEventHelper implementation:
 
 bool RootWindow::CanDispatchToConsumer(ui::GestureConsumer* consumer) {
   Window* consumer_window = ConsumerToWindow(consumer);;
   return (consumer_window && consumer_window->GetRootWindow() == window());
 }
 
-void RootWindow::DispatchPostponedGestureEvent(ui::GestureEvent* event) {
-  DispatchGestureEvent(event);
-}
-
 void RootWindow::DispatchCancelTouchEvent(ui::TouchEvent* event) {
   OnHostTouchEvent(event);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, ui::LayerAnimationObserver implementation:
 
 void RootWindow::OnLayerAnimationEnded(
     ui::LayerAnimationSequence* animation) {
   host()->UpdateRootWindowSize(host_->GetBounds().size());
@@ skipping 22 matching lines @@
   return event->handled() || details.dispatcher_destroyed;
 }
 
 bool RootWindow::OnHostScrollEvent(ui::ScrollEvent* event) {
   DispatchDetails details = OnEventFromSource(event);
   if (details.dispatcher_destroyed)
     event->SetHandled();
   return event->handled();
 }
 
+void RootWindow::OnTouchEventForGestures(
+    ui::TouchEvent* event,
+    ui::TouchPointState::RequiresAck requires_ack) {
+  Window* target = GetTouchEventTarget(event);
+  if (target)
+    event->ConvertLocationToTarget(target, window());
+  if (!gesture_event_queues_[target])
+    gesture_event_queues_[target] = new ui::GestureEventQueue(this);
+  ui::GestureEventQueue* gesture_event_queue = gesture_event_queues_[target];
+  gesture_event_queue->OnTouchEvent(*event);
+  // Get the list of GestureEvents from GestureRecognizer.
+  scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
+  gestures.reset(
+      ui::GestureRecognizer::Get()->ProcessTouchEventForGesture(
+          *event, target, gesture_event_queue));
+  for (ui::GestureRecognizer::Gestures::iterator it = gestures->begin();
+       it != gestures->end();
+       ++it) {
+    gesture_event_queue->QueueGestureEvent(*it, requires_ack);
+  }
+  gestures->weak_clear();
+}
+
 bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
+  TransformEventForDeviceScaleFactor(event);
+
+  Window* target = GetTouchEventTarget(event);
+
+  if (target)
+    event->ConvertLocationToTarget(window(), target);
+
   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();
   if (details.dispatcher_destroyed)
     return false;
-  details = DispatchTouchEventImpl(event);
+  details = DispatchTouchEventImpl(event, target);
+  if (event->result() == ui::ER_UNHANDLED)
+    OnTouchEventForGestures(event, ui::TouchPointState::NO_ACK);
   if (details.dispatcher_destroyed)
     return true;
   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);
@@ skipping 177 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) {
+    ui::TouchEvent* event, Window* target) {
+  if (!target)
+    return DispatchDetails();
+
   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());
+  DispatchDetails details = DispatchEvent(target, event);
+  return details;
 }
 
 ui::EventDispatchDetails RootWindow::DispatchHeldEvents() {
   if (!held_repostable_event_ && !held_move_event_)
     return DispatchDetails();
 
   CHECK(!dispatching_held_event_);
   dispatching_held_event_ = true;
 
   DispatchDetails dispatch_details;
@@ skipping 13 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()) {
+    ui::TouchEvent* touch_event =
+        static_cast<ui::TouchEvent*>(held_move_event_.get());
     dispatch_details = DispatchTouchEventImpl(
-        static_cast<ui::TouchEvent*>(held_move_event_.get()));
+        touch_event, GetTouchEventTarget(touch_event));
     if (!dispatch_details.dispatcher_destroyed)
       held_move_event_.reset();
   }
 
   if (!dispatch_details.dispatcher_destroyed)
     dispatching_held_event_ = false;
   return dispatch_details;
 }
 
 void RootWindow::PostMouseMoveEventAfterWindowChange() {
@@ skipping 37 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;
   }
 }
 
+Window* RootWindow::GetTouchEventTarget(ui::TouchEvent* 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()));
+    }
+  }
+
+  if (!target && !window()->bounds().Contains(event->location())) {
+    // If the initial touch is outside the root window, target the root.
+    target = window();
+    if (!target)
+      target = this->window();
+  } else {
+    // We only come here when the first contact was within the root window.
+    if (!target)
+      target = window()->GetEventHandlerForPoint(event->location());
+  }
+  return target;
+}
+
 }  // namespace aura