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 rect_1_area ? intersection_area / rect_1_area : 0;
+}
+
+// The positive distance from |pos| to the nearest endpoint of the interval
+// [start, end] is returned if |pos| lies within the interval, otherwise
+// 0 is returned.
+int DistanceToInterval(int pos, int start, int end) {
+  if (pos < start)
+    return start - pos;
+  if (pos > end)
+    return pos - end;
+  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 526 matching lines @@
     target->ConvertPointFromAncestor(root, point);
 
   // API defines NULL |source| as returning the point in screen coordinates.
   if (!source) {
     *point = point->Subtract(
         root->GetWidget()->GetClientAreaBoundsInScreen().origin());
   }
 }
 
 // static
+void View::ConvertRectToView(const View* source,
+                             const View* target,
+                             gfx::Rect* rect) {
+  gfx::Point rect_location(rect->x(), rect->y());
+  View::ConvertPointToView(source, target, &rect_location);
+  rect->set_origin(rect_location);
+}
+
+// static
 void View::ConvertPointToWidget(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   src->ConvertPointForAncestor(NULL, p);
 }
 
 // static
 void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) {
   DCHECK(dest);
@@ skipping 117 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& rect) {

[sky, 2012/08/03 23:46:36]

I'm hoping its possible to combine this and GetEventHandlerForPoint. Less error
prone that way. I'm thinking something like this:

struct EventHandlerResult {
  View* view_at_center;
  View* best_view;
};

bool GetEventHandlerForRect(..., EventHandlerResult* result) {
}

[sky, 2012/08/03 23:52:57]

Gah, I guess I can't nuke my comments.
Here's my second thought. This requires two passes, but combines the two methods
into a single one:

enum EventType {
  MOUSE,
  TOUCH
};
name this GetEventHandler(const gfx::Rect& rect, EventType type);

+  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->bounds());
+    if (!child_rect.Intersects(rect))
+      continue;
+
+    gfx::Rect rect_in_child_coords(rect);
+    View::ConvertRectToView(this, child, &rect_in_child_coords);
+    View* cur_view = child->GetEventHandlerForRect(rect_in_child_coords);
+    if (!cur_view)

[sky, 2012/08/03 23:46:36]

between 830-831 something like:

if (rect.IsEmpty() && result->view_at_center)
  return true;
cur_view becomes result->best_view.

[sky, 2012/08/03 23:52:57]

if (type == MOUSE)
  return cur_view;

+      continue;
+
+    gfx::Point touch_center(rect.CenterPoint());
+    gfx::Rect cur_rect(cur_view->GetLocalBounds());
+    View::ConvertRectToView(cur_view, this, &cur_rect);
+    int cur_dist = DistanceSquaredFromCenterLineToPoint(touch_center,

[sky, 2012/08/03 23:46:36]

If GetEventHandlerForRect returns a view, don't we end up calculating this n -1
times for the same view where n is the depth to the view that returned itself?

+                                                        cur_rect);
+    if (!closest_view || cur_dist < best_dist_so_far) {
+      closest_view = cur_view;

[sky, 2012/08/03 23:46:36]

result->best_view = closest_view;

+      best_dist_so_far = cur_dist;
+    }
+  }
+

[sky, 2012/08/03 23:46:36]

if (!result->view_at_center && bounds().contains(center_point))
  result->view_at_center = this;

+  if (closest_view)
+    return closest_view;

[sky, 2012/08/03 23:46:36]

This would become return true.

+
+  gfx::Rect view_rect(GetLocalBounds());
+  if (PercentCoveredBy(view_rect, rect) >= kFuzzingOverlapPercentage)
+    return this;

[sky, 2012/08/03 23:46:36]

result->best_view = this; return true;

+  return NULL;

[sky, 2012/08/03 23:46:36]

return false;

[sky, 2012/08/03 23:52:57]

return type == MOUSE ? this : NULL;

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