Add gesture target fuzzing to views

ui/views/widget/root_view.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/views/widget/root_view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 434 matching lines @@
     return status;
   }
 
   // Reset touch_pressed_handler_ to indicate that no processing is occurring.
   touch_pressed_handler_ = NULL;
 
   return status;
 }
 
 ui::GestureStatus RootView::OnGestureEvent(const GestureEvent& event) {
-  GestureEvent e(event, this);

[sadrul, 2012/07/18 23:42:31]

This creates an event to take RootView's transforms (if any) into account. This
may not be needed anymore, but if so, then let's remove this (and similar cases
for mouse and touch events) in a separate CL.

[tdanderson, 2012/07/25 23:08:57]

Okay, I will put |e| back in for this CL.

   ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
 
+  // TODO(tdanderson): Store radius values for a ui::ET_GESTURE_LONG_PRESS
+  //                   event so that fuzzing may also be used for a long press.
+  if (event.type() == ui::ET_GESTURE_TAP) {
+    float radius = event.details().radius_x();
+    gfx::Point adjusted_loc(event.x() - radius, event.y() - radius);
+    ConvertPointToScreen(this, &adjusted_loc);
+    gfx::Rect touch_rect(adjusted_loc.x(),
+                         adjusted_loc.y(),
+                         radius * 2,
+                         radius * 2);
+
+    // If |new_gesture_handler| is not NULL, it should handle the tap event.
+    // Screen coordinates are used to eliminate the overhead of switching
+    // between parent/child coordinate systems in View::GetEventHandlerForRect.
+    View* new_gesture_handler = GetEventHandlerForRect(touch_rect);
+    if (new_gesture_handler) {
+      if (!gesture_handler_)

[sadrul, 2012/07/18 23:42:31]

brace

[tdanderson, 2012/07/25 23:08:57]

Done.

+        gesture_handler_ = new_gesture_handler;
+      else if (gesture_handler_ != new_gesture_handler) {
+        // Send an ET_GESTURE_END event to the original handler
+        GestureEvent end_event(ui::ET_GESTURE_END,
+                               event.x(),
+                               event.y(),
+                               event.flags());
+        gesture_handler_->ProcessGestureEvent(end_event);
+
+        // Send ET_GESTURE_BEGIN and ET_GESTURE_TAP_DOWN events to the new
+        // handler before processing the ET_GESTURE_TAP event.
+        gfx::Rect new_handler_bounds(new_gesture_handler->GetScreenBounds());
+        gfx::Point new_center(new_handler_bounds.CenterPoint());
+        ConvertPointFromScreen(this, &new_center);
+        GestureEvent begin_event(ui::ET_GESTURE_BEGIN,

[tdanderson, 2012/07/18 22:35:42]

sadrul@: you mentioned that I should make sure the details of |begin_event| and
|end_event| both have one touch point. Are there any other changes that are
needed?

[sadrul, 2012/07/18 23:42:31]

Yes. You need to update GestureEvent::details_ to make sure touch_points()
returns 1

[tdanderson, 2012/07/25 23:08:57]

This will no longer be relevant in the next CL.

+                                 new_center.x(),
+                                 new_center.y(),
+                                 event.flags());
+        new_gesture_handler->ProcessGestureEvent(begin_event);
+        GestureEvent tap_down_event(ui::ET_GESTURE_TAP_DOWN,
+                                    new_center.x(),
+                                    new_center.y(),
+                                    event.flags());
+        new_gesture_handler->ProcessGestureEvent(tap_down_event);
+
+        gesture_handler_ = new_gesture_handler;
+      }
+    }
+  }
+
   if (gesture_handler_) {
     // |gesture_handler_| (or |scroll_gesture_handler_|) can be deleted during
     // processing.
     View* handler = event.IsScrollGestureEvent() && scroll_gesture_handler_ ?
         scroll_gesture_handler_ : gesture_handler_;
     GestureEvent handler_event(event, this, handler);
 
     ui::GestureStatus status = handler->ProcessGestureEvent(handler_event);
 
     if (event.type() == ui::ET_GESTURE_END &&
@@ skipping 10 matching lines @@
 
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN &&
         !scroll_gesture_handler_) {
       // Some view started processing gesture events, however it does not
       // process scroll-gesture events. In such case, we allow the event to
       // bubble up, and install a different scroll-gesture handler different
       // from the default gesture handler.
       for (scroll_gesture_handler_ = gesture_handler_->parent();
           scroll_gesture_handler_ && scroll_gesture_handler_ != this;
           scroll_gesture_handler_ = scroll_gesture_handler_->parent()) {
-        GestureEvent gesture_event(e, this, scroll_gesture_handler_);
+        GestureEvent gesture_event(event, this, scroll_gesture_handler_);
         status = scroll_gesture_handler_->ProcessGestureEvent(gesture_event);
         if (status == ui::GESTURE_STATUS_CONSUMED)
           return status;
       }
       scroll_gesture_handler_ = NULL;
     }
 
     return ui::GESTURE_STATUS_UNKNOWN;
+

[sadrul, 2012/07/18 23:42:31]

-

[tdanderson, 2012/07/25 23:08:57]

Done.

   }
 
   // Walk up the tree until we find a view that wants the gesture event.
-  for (gesture_handler_ = GetEventHandlerForPoint(e.location());
+  for (gesture_handler_ = GetEventHandlerForPoint(event.location());
       gesture_handler_ && (gesture_handler_ != this);
       gesture_handler_ = gesture_handler_->parent()) {
     if (!gesture_handler_->enabled()) {
       // Disabled views eat events but are treated as not handled.
       return ui::GESTURE_STATUS_UNKNOWN;
     }
 
     // See if this view wants to handle the Gesture.
-    GestureEvent gesture_event(e, this, gesture_handler_);
+    GestureEvent gesture_event(event, this, gesture_handler_);
     status = gesture_handler_->ProcessGestureEvent(gesture_event);
 
     // The view could have removed itself from the tree when handling
     // OnGestureEvent(). So handle as per OnMousePressed. NB: we
     // assume that the RootView itself cannot be so removed.
     if (!gesture_handler_)
       return ui::GESTURE_STATUS_UNKNOWN;
 
     if (status == ui::GESTURE_STATUS_CONSUMED) {
       if (gesture_event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
@@ skipping 79 matching lines @@
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
 }  // namespace internal
 }  // namespace views