Add gesture target fuzzing to views

ui/views/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/view.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/accessibility/accessibility_types.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/point3.h"
 #include "ui/gfx/transform.h"
 #include "ui/views/background.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/layout/layout_manager.h"
+#include "ui/views/view_constants.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #include "ui/views/accessibility/native_view_accessibility_win.h"
 #endif
@@ skipping 33 matching lines @@
 };
 
 // Returns the top view in |view|'s hierarchy.
 const views::View* GetHierarchyRoot(const views::View* view) {
   const views::View* root = view;
   while (root && root->parent())
     root = root->parent();
   return root;
 }
 
+// Returns the percentage of |rect_1|'s area that is covered by |rect_2|.
+float PercentCoveredBy(const gfx::Rect& rect_1, const gfx::Rect& rect_2) {
+  gfx::Rect intersection(rect_1.Intersect(rect_2));
+  float intersection_area = intersection.size().GetArea();
+  float rect_1_area = rect_1.size().GetArea();
+  return intersection_area / rect_1_area;
+}
+
+int DistanceToInterval(int pos, int start, int end) {
+  if (pos < start)
+    return start - pos;
+  if (pos > end)
+    return end - pos;
+  return 0;
+}
+
+// Returns the square of the distance from |point| to the center line of
+// |target_rect|. The center line of a rectangle is obtained by repeatedly
+// stripping away 1px borders around the rectangle until a line remains.
+int DistanceSquaredFromCenterLineToPoint(const gfx::Point& point,
+                                         const gfx::Rect& target_rect) {
+  gfx::Point center_point = target_rect.CenterPoint();
+  int dx = center_point.x() - point.x();
+  int dy = center_point.y() - point.y();
+
+  if (target_rect.width() > target_rect.height()) {
+    dx = DistanceToInterval(point.x(),
+                            target_rect.x() + (target_rect.height() / 2),
+                            target_rect.right() - (target_rect.height() / 2));
+  } else {
+    dy = DistanceToInterval(point.y(),
+                            target_rect.y() + (target_rect.width() / 2),
+                            target_rect.bottom() - (target_rect.width() / 2));
+  }
+
+  return (dx * dx) + (dy * dy);
+}
+
 }  // namespace
 
 namespace views {
 
 // static
 ViewsDelegate* ViewsDelegate::views_delegate = NULL;
 
 // static
 const char View::kViewClassName[] = "views/View";
 
@@ skipping 664 matching lines @@
       continue;
 
     gfx::Point point_in_child_coords(point);
     View::ConvertPointToView(this, child, &point_in_child_coords);
     if (child->HitTest(point_in_child_coords))
       return child->GetEventHandlerForPoint(point_in_child_coords);
   }
   return this;
 }
 
+View* View::GetEventHandlerForRect(const gfx::Rect& touch_rect) {
+  if (!child_count()) {
+    gfx::Rect view_rect(GetBoundsInScreen());
+    if (PercentCoveredBy(view_rect, touch_rect) >= kFuzzingOverlapPercentage)
+      return this;
+    return NULL;

[sadrul, 2012/07/26 18:41:28]

I still think as long as the touch_rect intersection with bounds is non-empty,
it should return |this| here.

[tdanderson, 2012/07/27 15:27:04]

We talked about this offline, but for the benefit of the other reviewers I will
summarize the outcome of our discussion.

This function only considers small targets (targets that can be covered by your
finger by at least ~70%), whereas GetEventHandlerForPoint considers all targets
containing a single point regardless of size.

The approach (which is clearer to see in the next CL) to finding a gesture
handler in RootView::OnGestureEvent is to first consider small targets using
GetEventHandlerForRect since these are hardest to touch. If this call returns
something, then it's likely what the user wanted to touch. If the call to
GetEventHandlerForRect in RootView::OnGestureEvent returns NULL, we then try to
find a gesture handler by calling GetEventHandlerForPoint (which is what this
code did originally). This will handle the case where the user is trying to
touch a large target such as a tab. Large targets don't need fuzzing since it
should be easy to precisely target a view that has a larger area than your
finger.

+  }
+
+  View* closest_view = NULL;
+  int best_dist_so_far = INT_MAX;
+  for (int i = child_count() - 1; i >= 0; --i) {
+    View* child = child_at(i);
+    if (!child->visible())
+      continue;
+
+    gfx::Rect child_rect(child->GetBoundsInScreen());
+    if (!child_rect.Intersects(touch_rect))
+      continue;
+
+    View* cur_view = child->GetEventHandlerForRect(touch_rect);
+    if (!cur_view)
+      continue;
+
+    gfx::Point touch_center(touch_rect.CenterPoint());
+    gfx::Rect cur_rect(cur_view->GetBoundsInScreen());
+    int cur_dist = DistanceSquaredFromCenterLineToPoint(touch_center,
+                                                        cur_rect);
+    if (!closest_view || cur_dist < best_dist_so_far) {
+      closest_view = cur_view;
+      best_dist_so_far = cur_dist;
+    }
+  }
+
+  return closest_view;
+}
+
 gfx::NativeCursor View::GetCursor(const MouseEvent& event) {
 #if defined(OS_WIN) && !defined(USE_AURA)
   static HCURSOR arrow = LoadCursor(NULL, IDC_ARROW);
   return arrow;
 #else
   return gfx::kNullCursor;
 #endif
 }
 
 bool View::HitTest(const gfx::Point& l) const {
@@ skipping 1330 matching lines @@
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   GetWidget()->RunShellDrag(this, data, widget_location, drag_operations);
   return true;
 #else
   return false;
 #endif  // !defined(OS_MACOSX)
 }
 
 }  // namespace views