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 distance from |point| to the center line of |target_rect|.

[rjkroege, 2012/07/19 00:51:57]

square of the distance -- comment not consistent with code.

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

Done.

+// 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(GetScreenBounds());
+    if (PercentCoveredBy(view_rect, touch_rect) >= kFuzzingOverlapPercentage)
+      return this;
+    return NULL;

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

I think as long as the intersection is non-empty, this should return |this|.
Otherwise, if the View is big without any child views, it will end up returning
NULL

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

This is the behavior that I want since only small targets get the benefit of
fuzzing. If GetEventHandlerForRect returns NULL, it means that there are no
small targets sufficiently near the center of the touch region and so you
probably meant to target something larger. In this case the for loop at the end
of the function is entered which performs targeting based only on the center of
the touch region (and you should have no problem making the center of the touch
region fall within the bounds of a big target).

+  }
+
+  View* closest_view = NULL;
+  for (int i = child_count() - 1; i >= 0; --i) {
+    View* child = child_at(i);
+
+    if (!child->visible())
+      continue;
+
+    gfx::Rect child_rect(child->GetScreenBounds());
+    if (!child_rect.Intersects(touch_rect))
+      continue;
+
+    View* cur_view = child->GetEventHandlerForRect(touch_rect);
+
+    if (!closest_view)

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

braces (since else has them)

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

Done.

+      closest_view = cur_view;
+    else if (cur_view) {
+      gfx::Point touch_center(touch_rect.CenterPoint());
+      gfx::Rect closest_view_rect(closest_view->GetScreenBounds());
+      gfx::Rect cur_rect(cur_view->GetScreenBounds());
+
+      int best_dist_so_far = DistanceSquaredFromCenterLineToPoint(
+          touch_center,
+          closest_view_rect);
+      int cur_dist = DistanceSquaredFromCenterLineToPoint(touch_center,
+                                                          cur_rect);
+
+      if (cur_dist < best_dist_so_far)
+        closest_view = cur_view;

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

Can you remember best_dist_so_far instead of computing it every time?

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

Done.

+    }
+  }
+
+  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 1328 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