Support targeting for gestures in ViewTargeter

ui/views/view_targeter_unittest.cc

 // Copyright 2014 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_targeter.h"
 
 #include "ui/events/event_targeter.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/path.h"
 #include "ui/views/masked_targeter_delegate.h"
@@ skipping 58 matching lines @@
     mask->lineTo(0, h);
     mask->close();
     return true;
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestMaskedView);
 };
 
 namespace test {
 
-typedef ViewsTestBase ViewTargeterTest;
+// TODO(tdanderson): Clean up this test suite by moving common code/state into
+//                   ViewTargeterTest and overriding SetUp(), TearDown(), etc.
+//                   See crbug.com/355680.
+class ViewTargeterTest : public ViewsTestBase {
+ public:
+  ViewTargeterTest() {}
+  virtual ~ViewTargeterTest() {}
+
+  void SetGestureHandler(internal::RootView* root_view, View* handler) {
+    root_view->gesture_handler_ = handler;
+  }
+
+  void SetAllowGestureEventRetargeting(internal::RootView* root_view,
+                                       bool allow) {
+    root_view->allow_gesture_event_retargeting_ = allow;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ViewTargeterTest);
+};
 
 namespace {
 
 gfx::Point ConvertPointToView(View* view, const gfx::Point& p) {
   gfx::Point tmp(p);
   View::ConvertPointToTarget(view->GetWidget()->GetRootView(), view, &tmp);
   return tmp;
 }
 
 gfx::Rect ConvertRectToView(View* view, const gfx::Rect& r) {
@@ skipping 20 matching lines @@
 
   widget.SetContentsView(content);
   content->AddChildView(child);
   child->AddChildView(grandchild);
 
   grandchild->SetFocusable(true);
   grandchild->RequestFocus();
 
   internal::RootView* root_view =
       static_cast<internal::RootView*>(widget.GetRootView());
-  ViewTargeter* view_targeter = new ViewTargeter(root_view);
-  ui::EventTargeter* targeter = view_targeter;
-  root_view->SetEventTargeter(make_scoped_ptr(view_targeter));
+  ui::EventTargeter* targeter = root_view->targeter();
 
   ui::KeyEvent key_event('a', ui::VKEY_A, ui::EF_NONE);
 
   // The focused view should be the initial target of the event.
   ui::EventTarget* current_target = targeter->FindTargetForEvent(root_view,
                                                                  &key_event);
   EXPECT_EQ(grandchild, static_cast<View*>(current_target));
 
   // Verify that FindNextBestTarget() will return the parent view of the
   // argument (and NULL if the argument has no parent view).
@@ skipping 26 matching lines @@
   child->SetBounds(50, 50, 20, 20);
   View* grandchild = new View;
   grandchild->SetBounds(0, 0, 5, 5);
 
   widget.SetContentsView(content);
   content->AddChildView(child);
   child->AddChildView(grandchild);
 
   internal::RootView* root_view =
       static_cast<internal::RootView*>(widget.GetRootView());
-  ViewTargeter* view_targeter = new ViewTargeter(root_view);
-  ui::EventTargeter* targeter = view_targeter;
-  root_view->SetEventTargeter(make_scoped_ptr(view_targeter));
+  ui::EventTargeter* targeter = root_view->targeter();
 
   // The event falls within the bounds of |child| and |content| but not
   // |grandchild|, so |child| should be the initial target for the event.
   ui::ScrollEvent scroll(ui::ET_SCROLL,
                          gfx::Point(60, 60),
                          ui::EventTimeForNow(),
                          0,
                          0, 3,
                          0, 3,
                          2);
@@ skipping 19 matching lines @@
                            gfx::Point(150, 150),
                            ui::EventTimeForNow(),
                            0,
                            0, 3,
                            0, 3,
                            2);
   current_target = targeter->FindTargetForEvent(root_view, &scroll);
   EXPECT_EQ(content, static_cast<View*>(current_target));
 }
 
+// Convenience to make constructing a GestureEvent simpler.
+class GestureEventForTest : public ui::GestureEvent {
+ public:
+  GestureEventForTest(ui::EventType type, int x, int y)
+      : GestureEvent(x,
+                     y,
+                     0,
+                     base::TimeDelta(),
+                     ui::GestureEventDetails(type, 0.0f, 0.0f)) {}
+
+  GestureEventForTest(ui::GestureEventDetails details, int x, int y)
+      : GestureEvent(x, y, 0, base::TimeDelta(), details) {}
+};
+
+// Verifies that the the functions ViewTargeter::FindTargetForEvent()
+// and ViewTargeter::FindNextBestTarget() are implemented correctly
+// for gesture events.
+TEST_F(ViewTargeterTest, ViewTargeterForGestureEvents) {
+  Widget widget;
+  Widget::InitParams init_params = CreateParams(Widget::InitParams::TYPE_POPUP);
+  init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  init_params.bounds = gfx::Rect(0, 0, 200, 200);
+  widget.Init(init_params);
+
+  // The coordinates used for SetBounds() are in the parent coordinate space.
+  View* content = new View;
+  content->SetBounds(0, 0, 100, 100);
+  View* child = new View;
+  child->SetBounds(50, 50, 20, 20);
+  View* grandchild = new View;
+  grandchild->SetBounds(0, 0, 5, 5);
+
+  widget.SetContentsView(content);
+  content->AddChildView(child);
+  child->AddChildView(grandchild);
+
+  internal::RootView* root_view =
+      static_cast<internal::RootView*>(widget.GetRootView());
+  ui::EventTargeter* targeter = root_view->targeter();
+
+  // Define a GESTURE_TAP and a GESTURE_SCROLL_BEGIN.
+  gfx::Rect bounding_box(gfx::Point(46, 46), gfx::Size(8, 8));
+  gfx::Point center_point(bounding_box.CenterPoint());
+  ui::GestureEventDetails details(ui::ET_GESTURE_TAP, 0.0f, 0.0f);
+  details.set_bounding_box(bounding_box);
+  GestureEventForTest tap(details, center_point.x(), center_point.y());
+  details = ui::GestureEventDetails(ui::ET_GESTURE_SCROLL_BEGIN, 0.0f, 0.0f);
+  details.set_bounding_box(bounding_box);
+  GestureEventForTest scroll_begin(details, center_point.x(), center_point.y());
+
+  // Assume that the view currently handling gestures has been set as
+  // |grandchild| by a previous gesture event. Thus subsequent gesture events
+  // should be initially targeted to |grandchild|, and re-targeting should
+  // be prohibited for all gesture event types except for GESTURE_SCROLL_BEGIN
+  // (which should be re-targeted to the parent of |grandchild|).
+  SetAllowGestureEventRetargeting(root_view, false);
+  SetGestureHandler(root_view, grandchild);
+  EXPECT_EQ(grandchild, targeter->FindTargetForEvent(root_view, &tap));
+  EXPECT_EQ(NULL, targeter->FindNextBestTarget(grandchild, &tap));
+  EXPECT_EQ(grandchild, targeter->FindTargetForEvent(root_view, &scroll_begin));
+  EXPECT_EQ(child, targeter->FindNextBestTarget(grandchild, &scroll_begin));
+
+  // Assume that the view currently handling gestures is still set as
+  // |grandchild|, but this was not done by a previous gesture. Thus we are
+  // in the process of finding the View to which subsequent gestures will be
+  // dispatched, so all gesture events should be re-targeted up the ancestor
+  // chain.
+  SetAllowGestureEventRetargeting(root_view, true);
+  EXPECT_EQ(child, targeter->FindNextBestTarget(grandchild, &tap));
+  EXPECT_EQ(child, targeter->FindNextBestTarget(grandchild, &scroll_begin));
+
+  // Assume that the default gesture handler was set by the previous gesture,
+  // but that this handler is currently NULL. No gesture events should be
+  // re-targeted in this case (regardless of the view that is passed in to
+  // FindNextBestTarget() as the previous target).
+  SetGestureHandler(root_view, NULL);
+  SetAllowGestureEventRetargeting(root_view, false);
+  EXPECT_EQ(NULL, targeter->FindNextBestTarget(child, &tap));
+  EXPECT_EQ(NULL, targeter->FindNextBestTarget(NULL, &tap));
+  EXPECT_EQ(NULL, targeter->FindNextBestTarget(content, &scroll_begin));
+
+  // If no default gesture handler is currently set, targeting should be
+  // performed using the location of the gesture event.
+  SetAllowGestureEventRetargeting(root_view, true);
+  EXPECT_EQ(grandchild, targeter->FindTargetForEvent(root_view, &tap));
+  EXPECT_EQ(grandchild, targeter->FindTargetForEvent(root_view, &scroll_begin));
+}
+
 // Tests that the functions ViewTargeterDelegate::DoesIntersectRect()
 // and MaskedTargeterDelegate::DoesIntersectRect() work as intended when
 // called on views which are derived from ViewTargeterDelegate.
 // Also verifies that ViewTargeterDelegate::DoesIntersectRect() can
 // be called from the ViewTargeter installed on RootView.
 TEST_F(ViewTargeterTest, DoesIntersectRect) {
   Widget widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 650, 650);
   widget.Init(params);
 
   internal::RootView* root_view =
       static_cast<internal::RootView*>(widget.GetRootView());
-  ViewTargeter* view_targeter = new ViewTargeter(root_view);
-  root_view->SetEventTargeter(make_scoped_ptr(view_targeter));
+  ViewTargeter* view_targeter = root_view->targeter();
 
   // The coordinates used for SetBounds() are in the parent coordinate space.
   TestingView v2;
   TestMaskedView v1, v3;
   v1.SetBounds(0, 0, 200, 200);
   v2.SetBounds(300, 0, 300, 300);
   v3.SetBounds(0, 0, 100, 100);
   root_view->AddChildView(&v1);
   root_view->AddChildView(&v2);
   v2.AddChildView(&v3);
@@ skipping 100 matching lines @@
   EXPECT_EQ(v1, root_view->GetTooltipHandlerForPoint(v1_origin));
   EXPECT_EQ(root_view, root_view->GetTooltipHandlerForPoint(v2_origin));
 
   EXPECT_FALSE(v1->GetTooltipHandlerForPoint(v2_origin));
 
   widget->CloseNow();
 }
 
 }  // namespace test
 }  // namespace views