Add support for reposting the ET_GESTURE_TAP_DOWN gesture event to the RootWindow and in the

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 198 matching lines @@
   host_->Hide();
 }
 
 void RootWindow::PrepareForShutdown() {
   host_->PrepareForShutdown();
   // discard synthesize event request as well.
   synthesize_mouse_move_ = false;
 }
 
 void RootWindow::RepostEvent(const ui::LocatedEvent& event) {
+  if (event.type() != ui::ET_MOUSE_PRESSED &&

[sky, 2013/08/22 22:07:16]

I think this should just be a DCHECK. Also, document it in the header.

[ananta, 2013/08/22 22:48:15]

Done.

+      event.type() != ui::ET_GESTURE_TAP_DOWN) {
+    NOTREACHED() << "Invalid event type: " << event.type();
+    return;
+  }
   // We allow for only one outstanding repostable event. This is used
   // in exiting context menus.  A dropped repost request is allowed.
   if (event.type() == ui::ET_MOUSE_PRESSED) {
     held_repostable_event_.reset(
         new ui::MouseEvent(
             static_cast<const ui::MouseEvent&>(event),
             static_cast<aura::Window*>(event.target()),
             static_cast<aura::Window*>(this)));
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&RootWindow::DispatchHeldEvents,
-                   repostable_event_factory_.GetWeakPtr()));
   } else {
-    DCHECK(event.type() == ui::ET_GESTURE_TAP_DOWN);
-    held_repostable_event_.reset();
-    // TODO(sschmitz): add similar code for gesture events.
+    const ui::GestureEvent* gesture_event =
+        static_cast<const ui::GestureEvent*>(&event);
+    held_repostable_event_.reset(new ui::GestureEvent(
+        gesture_event->type(),
+        gesture_event->root_location().x(),
+        gesture_event->root_location().y(),
+        gesture_event->flags(),
+        gesture_event->time_stamp(),
+        gesture_event->details(),
+        gesture_event->touch_ids_bitfield()));
   }
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&RootWindow::DispatchHeldEvents,
+                  repostable_event_factory_.GetWeakPtr()));
 }
 
 RootWindowHostDelegate* RootWindow::AsRootWindowHostDelegate() {
   return this;
 }
 
 void RootWindow::SetHostSize(const gfx::Size& size_in_pixel) {
   DispatchHeldEvents();
   gfx::Rect bounds = host_->GetBounds();
   bounds.set_size(size_in_pixel);
@@ skipping 764 matching lines @@
 }
 
 bool RootWindow::DispatchMouseEventRepost(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_PRESSED)
     return false;
   mouse_pressed_handler_ = NULL;
   Window* target = GetEventHandlerForPoint(event->location());
   return DispatchMouseEventToTarget(event, target);
 }
 
+bool RootWindow::DispatchGestureEventRepost(ui::GestureEvent* event) {
+  if (event->type() != ui::ET_GESTURE_TAP_DOWN)
+    return false;
+
+  // Cleanup stale gesture events for the old gesture target.
+  GestureConsumer* old_consumer = GetGestureTarget(event);
+  if (old_consumer) {

[sky, 2013/08/22 22:07:16]

nit: no {}

[ananta, 2013/08/22 22:48:15]

Done.

+    CleanupGestureRecognizerState(static_cast<aura::Window*>(old_consumer));
+  }
+
+  Window* new_consumer = GetEventHandlerForPoint(event->root_location());
+  if (new_consumer) {
+    ProcessEvent(new_consumer, event);
+    return event->handled();
+  }
+  return false;
+}
+
 bool RootWindow::DispatchMouseEventToTarget(ui::MouseEvent* event,
                                             Window* target) {
   client::CursorClient* cursor_client = client::GetCursorClient(this);
   if (cursor_client &&
       !cursor_client->IsMouseEventsEnabled() &&
       (event->flags() & ui::EF_IS_SYNTHESIZED))
     return false;
 
   static const int kMouseButtonFlagMask =
       ui::EF_LEFT_MOUSE_BUTTON |
@@ skipping 107 matching lines @@
       event_for_gr, result, target));
 
   return ProcessGestures(gestures.get()) ? true : handled;
 }
 
 void RootWindow::DispatchHeldEvents() {
   if (held_repostable_event_) {
     if (held_repostable_event_->type() == ui::ET_MOUSE_PRESSED) {
       ui::MouseEvent mouse_event(
           static_cast<const ui::MouseEvent&>(*held_repostable_event_.get()));
-      held_repostable_event_.reset(); // must be reset before dispatch
+      held_repostable_event_.reset();  // must be reset before dispatch
       DispatchMouseEventRepost(&mouse_event);
     } else {
       DCHECK(held_repostable_event_->type() == ui::ET_GESTURE_TAP_DOWN);
-      // TODO(sschmitz): add similar code for gesture events
+      ui::GestureEvent gesture_event(
+          static_cast<const ui::GestureEvent&>(*held_repostable_event_.get()));
+      held_repostable_event_.reset();  // must be reset before dispatch
+      DispatchGestureEventRepost(&gesture_event);
     }
     held_repostable_event_.reset();
   }
   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_)
       DispatchMouseEventImpl(
           static_cast<ui::MouseEvent*>(held_move_event_.get()));
     held_move_event_.reset();
@@ skipping 32 matching lines @@
 }
 
 gfx::Transform RootWindow::GetInverseRootTransform() const {
   float scale = ui::GetDeviceScaleFactor(layer());
   gfx::Transform transform;
   transform.Scale(1.0f / scale, 1.0f / scale);
   return transformer_->GetInverseTransform() * transform;
 }
 
 }  // namespace aura