Initial views touchui GestureRecognizer support

views/view_unittest.cc

 // Copyright (c) 2011 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 <map>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 19 matching lines @@
 #include "views/focus/accelerator_handler.h"
 #include "views/focus/view_storage.h"
 #include "views/test/views_test_base.h"
 #include "views/touchui/gesture_manager.h"
 #include "views/view.h"
 #include "views/views_delegate.h"
 #include "views/widget/native_widget.h"
 #include "views/widget/root_view.h"
 #include "views/window/dialog_delegate.h"
 
+#if defined(TOUCH_UI)
+// TODO(Gajen): This voilates Google coding style but placing this above
+// testing/gmock/include/gmock/gmock.h doesn't let gtest to compile.
+#include <X11/Xlib.h>

[rjkroege, 2011/11/09 02:43:30]

I think that the need for this here is a sign of a problem. Can you explain why
this is necessary?

[Gajen, 2011/11/09 18:14:43]

This was required to instantiate base::NativeEvent (i.e XEvent*) for setting
native_event_ of Event in views/event/event.h. If we get some way to set
native_event_ this wont be required, need further discussion on this, captured
some thoughts on below similar comment.

[Gajen, 2011/11/10 15:52:55]

Deprecated, currently MockGesture is used for GM. A real GM can only be used if
we are able to properly convert Touch to Mouse event and propagation.
A separate CL http://codereview.chromium.org/8521001/ is submitted for same.

+#endif
+
 #if defined(OS_WIN)
 #include "views/test/test_views_delegate.h"
 #endif
 #if defined(USE_AURA)
 #include "ui/aura/desktop.h"
 #endif
+#if defined(TOUCH_UI)
+#include "views/touchui/gesture_recognizer.h"
+#endif
 
 using ::testing::_;
 
 namespace {
 
 // Returns true if |ancestor| is an ancestor of |layer|.
 bool LayerIsAncestor(const ui::Layer* ancestor, const ui::Layer* layer) {
   while (layer && layer != ancestor)
     layer = layer->parent();
   return layer == ancestor;
@@ skipping 141 matching lines @@
   TestView() : View(), in_touch_sequence_(false) {}
   virtual ~TestView() {}
 
   // Reset all test state
   void Reset() {
     did_change_bounds_ = false;
     last_mouse_event_type_ = 0;
     location_.SetPoint(0, 0);
     last_touch_event_type_ = 0;
     last_touch_event_was_handled_ = false;
+    last_gesture_event_type_ = 0;
+    last_gesture_event_was_handled_ = false;
     last_clip_.setEmpty();
     accelerator_count_map_.clear();
   }
 
   virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE;
   virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE;
   virtual bool OnMouseDragged(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const MouseEvent& event) OVERRIDE;
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
+
+  // Ignores GestureEvent by default.
+  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event) OVERRIDE;
   virtual void Paint(gfx::Canvas* canvas) OVERRIDE;
   virtual void SchedulePaintInRect(const gfx::Rect& rect) OVERRIDE;
   virtual bool AcceleratorPressed(const Accelerator& accelerator) OVERRIDE;
 
   // OnBoundsChanged.
   bool did_change_bounds_;
   gfx::Rect new_bounds_;
 
   // MouseEvent.
   int last_mouse_event_type_;
   gfx::Point location_;
 
   // Painting.
   std::vector<gfx::Rect> scheduled_paint_rects_;
 
   // TouchEvent.
   int last_touch_event_type_;
   bool last_touch_event_was_handled_;
   bool in_touch_sequence_;
 
+  // GestureEvent
+  int last_gesture_event_type_;
+  bool last_gesture_event_was_handled_;
+
   // Painting.
   SkRect last_clip_;
 
   // Accelerators.
   std::map<Accelerator, int> accelerator_count_map_;
 };
 
 // Mock instance of the GestureManager for testing.
 class MockGestureManager : public GestureManager {
  public:
@@ skipping 11 matching lines @@
   MockGestureManager();
 
   bool previously_handled_flag_;
   int last_touch_event_;
   View *last_view_;
   bool dispatched_synthetic_event_;
 
   DISALLOW_COPY_AND_ASSIGN(MockGestureManager);
 };
 
+// GestureRecognizer for testing.
+class TestGestureRecognizer: public GestureRecognizer {
+ public:
+  // Reset all test state.
+  void reset() {
+    last_touch_event_ = 0;
+    last_gesture_event_ = 0;
+    last_view_ = NULL;
+    previously_handled_flag_ = false;
+    dispatched_synthetic_event_ = false;
+  }
+
+  virtual bool ProcessTouchEventForGesture(const TouchEvent& event,
+                                           View* source,
+                                           ui::TouchStatus status) OVERRIDE;
+  TestGestureRecognizer();
+
+  bool previously_handled_flag_;
+  int last_touch_event_;
+  int last_gesture_event_;
+  View *last_view_;
+  bool dispatched_synthetic_event_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestGestureRecognizer);
+};
+
 // A view subclass that ignores all touch events for testing purposes.
 class TestViewIgnoreTouch : public TestView {
  public:
   TestViewIgnoreTouch() : TestView() {}
   virtual ~TestViewIgnoreTouch() {}
 
  private:
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
 };
 
+// A view subclass that consumes all Gesture events for testing purposes.
+class TestViewConsumeGesture : public TestView {
+ public:
+  TestViewConsumeGesture() : TestView() {}
+  virtual ~TestViewConsumeGesture() {}
+
+ private:
+  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
+  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event) OVERRIDE;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // OnBoundsChanged
 ////////////////////////////////////////////////////////////////////////////////
 
 void TestView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   did_change_bounds_ = true;
   new_bounds_ = bounds();
 }
 
 TEST_F(ViewTest, OnBoundsChanged) {
@@ skipping 244 matching lines @@
   EXPECT_EQ(v1->last_touch_event_type_, 0);
 
   EXPECT_EQ(gm.last_touch_event_, 0);
   EXPECT_EQ(NULL, gm.last_view_);
   EXPECT_EQ(gm.previously_handled_flag_, false);
 
   widget->CloseNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// GestureEvent
+////////////////////////////////////////////////////////////////////////////////
+
+bool TestGestureRecognizer::ProcessTouchEventForGesture(
+    const TouchEvent& event,
+    View* source,
+    ui::TouchStatus status) {
+  if (status != ui::TOUCH_STATUS_UNKNOWN) {
+    dispatched_synthetic_event_ = false;
+    return false;
+  }
+  last_touch_event_ =  event.type();
+  last_view_ = source;
+  previously_handled_flag_ = status != ui::TOUCH_STATUS_UNKNOWN;
+  dispatched_synthetic_event_ = GestureRecognizer::ProcessTouchEventForGesture(
+      event, source, status);
+  return true;
+}
+
+TestGestureRecognizer::TestGestureRecognizer() {
+}
+
+ui::GestureStatus TestView::OnGestureEvent(const GestureEvent& event) {
+  return ui::GESTURE_STATUS_UNKNOWN;
+}
+
+// GestureConsumer view should ignore TouchEvent for testing purposes.
+ui::TouchStatus TestViewConsumeGesture::OnTouchEvent(
+    const TouchEvent& event) {
+  return ui::TOUCH_STATUS_UNKNOWN;
+}
+
+ui::GestureStatus TestViewConsumeGesture::OnGestureEvent(
+    const GestureEvent& event) {
+  last_gesture_event_type_ = event.type();
+  location_.SetPoint(event.x(), event.y());
+  return ui::GESTURE_STATUS_CONSUMED;
+}
+
+#if defined(TOUCH_UI)
+TEST_F(ViewTest, GestureEvent) {
+  TestGestureRecognizer gm;
+
+  // Views hierarchy for non delivery of GestureEvent.
+  TestView* v1 = new TestViewConsumeGesture();
+  v1->SetBounds(0, 0, 300, 300);
+
+  TestView* v2 = new TestView();
+  v2->SetBounds(100, 100, 100, 100);
+
+  TestView* v3 = new TestViewConsumeGesture();
+  v3->SetBounds(0, 0, 100, 100);
+
+  // Views hierarchy for delivery of GestureEvent.
+  TestView* v4 = new TestViewConsumeGesture();
+  v4->SetBounds(200, 200, 100, 100);
+
+  scoped_ptr<Widget> widget(new Widget());
+  Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.bounds = gfx::Rect(50, 50, 650, 650);
+  widget->Init(params);
+  View* root = widget->GetRootView();
+
+  root->AddChildView(v1);
+  static_cast<internal::RootView*>(root)->SetGestureManagerForTesting(&gm);
+  v1->AddChildView(v2);
+  v2->AddChildView(v3);
+  v1->AddChildView(v4);
+
+  // |v3| completely obscures |v2|, but all the touch events on |v3| should

[rjkroege, 2011/11/09 02:43:30]

This is testing gesture events? Can you updated the comment.

[Gajen, 2011/11/10 15:52:55]

Done.

+  // reach |v2| because |v3| doesn't process any touch events, hence |v3|
+  // should also not recieve gesture events.
+
+  // Both |v4| and |v1| ignore touch events, hence |v4| should recieve gesture
+  // events.
+
+  // Make sure if none of the views handle the touch event, the gesture manager
+  // does.
+  v1->Reset();
+  v2->Reset();
+  v3->Reset();
+  v4->Reset();
+  gm.reset();
+
+  // Just to pass Touch to Mouse conversion process through
+  // EventFlagsFromNative(), EventLocationFromNative() in ui/base/x/events_x.cc.
+  XEvent native_event;
+  memset(&native_event, 0, sizeof(native_event));

[rjkroege, 2011/11/09 02:43:30]

this should not be necessary. You can construct the event directly. The native
event ought not to be necessary.

[Gajen, 2011/11/09 18:14:43]

Since, TouchEvent generated this way would set to some undefined pointer value
to native_event_(base::NativeEvent(i.e,XEvent*)) in base class Event. Which
in-turn Segfaults, During Conversion from TouchEvent to MouseEvent in
GestureManager::PTEFG(), during constructor calls
MouseEvent::MouseEvent(const TouchEvent& touch)
LocatedEvent::LocatedEvent(const NativeEvent& native_event)
EventFlagsFromNative()

So, to invoke Real GestureManager instead of Mock one we need some way to set
the native_event_.
A better solution to avoid inclusion of "X11" header and set_native_event() in
event.h, would be to set native_event_ directly in ctor of TouchEvent, but this
needs native_event_ be a protected member instead of private.
 Please let me know of any other solution.

[Gajen, 2011/11/10 15:52:55]

Deprecated, as new CL http://codereview.chromium.org/8521001/ would decide this.

+
+  TouchEvent unhandled(ui::ET_TOUCH_MOVED,
+                       400,
+                       400,
+                       0, /* no flags */
+                       0, /* first finger touch */
+                       1.0, 0.0, 1.0, 0.0);
+
+  unhandled.set_native_event(&native_event);
+  root->OnTouchEvent(unhandled);
+
+  EXPECT_EQ(v1->last_touch_event_type_, 0);
+  EXPECT_EQ(v2->last_touch_event_type_, 0);
+  EXPECT_EQ(v4->last_touch_event_type_, 0);
+  EXPECT_EQ(v4->last_gesture_event_type_, 0);
+
+  EXPECT_EQ(gm.previously_handled_flag_, false);
+  EXPECT_EQ(gm.last_touch_event_, ui::ET_TOUCH_MOVED);
+  EXPECT_EQ(gm.last_view_, root);
+  EXPECT_EQ(gm.dispatched_synthetic_event_, true);
+
+  // Test press, drag, release touch sequence.
+  v1->Reset();
+  v2->Reset();
+  v3->Reset();
+  v4->Reset();
+  gm.reset();
+
+  TouchEvent pressed(ui::ET_TOUCH_PRESSED,
+                     110,
+                     120,
+                     0, /* no flags */
+                     0, /* first finger touch */
+                     1.0, 0.0, 1.0, 0.0);
+  v2->last_touch_event_was_handled_ = true;
+  pressed.set_native_event(&native_event);
+  root->OnTouchEvent(pressed);
+
+  EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_PRESSED);
+  EXPECT_EQ(v2->location_.x(), 10);
+  EXPECT_EQ(v2->location_.y(), 20);
+  // Make sure v1 did not receive the event
+  EXPECT_EQ(v1->last_touch_event_type_, 0);
+
+  // Since v2 handled the touch-event, the gesture manager should not handle it.
+  EXPECT_EQ(gm.last_touch_event_, 0);
+  EXPECT_EQ(NULL, gm.last_view_);
+  EXPECT_EQ(gm.previously_handled_flag_, false);
+
+  // Drag event out of bounds. Should still go to v2
+  v1->Reset();
+  v2->Reset();
+  TouchEvent dragged(ui::ET_TOUCH_MOVED,
+                     50,
+                     40,
+                     0, /* no flags */
+                     0, /* first finger touch */
+                     1.0, 0.0, 1.0, 0.0);
+  dragged.set_native_event(&native_event);
+  root->OnTouchEvent(dragged);
+  EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_MOVED);
+  EXPECT_EQ(v2->location_.x(), -50);
+  EXPECT_EQ(v2->location_.y(), -60);
+  // Make sure v1 did not receive the event
+  EXPECT_EQ(v1->last_touch_event_type_, 0);
+
+  EXPECT_EQ(gm.last_touch_event_, 0);
+  EXPECT_EQ(NULL, gm.last_view_);
+  EXPECT_EQ(gm.previously_handled_flag_, false);
+
+  // Released event out of bounds. Should still go to v2
+  v1->Reset();
+  v2->Reset();
+  TouchEvent released(ui::ET_TOUCH_RELEASED, 0, 0, 0, 0 /* first finger */,
+                      1.0, 0.0, 1.0, 0.0);
+  released.set_native_event(&native_event);
+  v2->last_touch_event_was_handled_ = true;
+  root->OnTouchEvent(released);
+  EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_RELEASED);
+  EXPECT_EQ(v2->location_.x(), -100);
+  EXPECT_EQ(v2->location_.y(), -100);
+  // Make sure v1 did not receive the event
+  EXPECT_EQ(v1->last_touch_event_type_, 0);
+
+  EXPECT_EQ(gm.last_touch_event_, 0);
+  EXPECT_EQ(NULL, gm.last_view_);
+  EXPECT_EQ(gm.previously_handled_flag_, false);
+
+  // Gesture event handling test.
+  // 1) Test gesture type ui::ET_GESTURE_TAP_DOWN.
+  v1->Reset();
+  v4->Reset();
+  gm.reset();
+
+  TouchEvent second_pressed(ui::ET_TOUCH_PRESSED,
+                            210,
+                            220,
+                            0, /* no flags */
+                            0, /* first finger touch */
+                            1.0, 0.0, 1.0, 0.0);
+  second_pressed.set_native_event(&native_event);
+  base::Time pressed_time = second_pressed.time_stamp();
+  root->OnTouchEvent(second_pressed);
+
+  // Since v1 and V4 didn't handled touch event, the gesture manager should
+  // handle it.
+  EXPECT_EQ(gm.last_touch_event_, ui::ET_TOUCH_PRESSED);
+  EXPECT_EQ(root, gm.last_view_);
+  EXPECT_EQ(gm.previously_handled_flag_, false);
+
+  // Check v4 should receive gesture event but not v1.
+  EXPECT_EQ(v1->last_touch_event_type_, 0);
+  EXPECT_EQ(v4->last_touch_event_type_, 0);
+  EXPECT_EQ(v4->last_gesture_event_type_, ui::ET_GESTURE_TAP_DOWN);
+  EXPECT_EQ(v4->location_.x(), 10);
+  EXPECT_EQ(v4->location_.y(), 20);
+
+  // Check mouse conversions shouldn't take place.
+  EXPECT_EQ(gm.dispatched_synthetic_event_, false);
+
+  // 2) Test gesture type ui::ET_GESTURE_TAP.
+  v1->Reset();
+  v4->Reset();
+  gm.reset();
+
+  TouchEvent second_released(ui::ET_TOUCH_RELEASED,
+                      210,
+                      220,
+                      0, /* no flags */
+                      0, /* first finger touch */
+                      1.0, 0.0, 1.0, 0.0);
+  second_released.set_native_event(&native_event);
+
+  // Set touch time with-in click window.
+  second_released.set_time_stamp(base::Time::FromDoubleT(
+      pressed_time.ToDoubleT() + 0.7));
+  root->OnTouchEvent(second_released);
+
+  // Since v1 and V4 didn't handled touch event, the gesture manager should
+  // handle it.
+  EXPECT_EQ(gm.last_touch_event_, ui::ET_TOUCH_RELEASED);
+  EXPECT_EQ(root, gm.last_view_);
+  EXPECT_EQ(gm.previously_handled_flag_, false);
+
+  // Check v4 should receive gesture event but not v1.
+  EXPECT_EQ(v1->last_touch_event_type_, 0);
+  EXPECT_EQ(v4->last_touch_event_type_, 0);
+  EXPECT_EQ(v4->last_gesture_event_type_, ui::ET_GESTURE_TAP);
+  EXPECT_EQ(v4->location_.x(), 10);
+  EXPECT_EQ(v4->location_.y(), 20);
+
+  // Check mouse conversions shouldn't take place.

[rjkroege, 2011/11/09 02:43:30]

mouse conversions are in-use in actual code. Please verify via tests that they
continue to function properly. 

[Gajen, 2011/11/10 15:52:55]

Verified touch to mouse conversion and propagation by applying new CL
http://codereview.chromium.org/8521001/, once this CL is approved  will change
accordingly.

+  EXPECT_EQ(gm.dispatched_synthetic_event_, false);
+  widget->CloseNow();
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
 // Painting
 ////////////////////////////////////////////////////////////////////////////////
 
 void TestView::Paint(gfx::Canvas* canvas) {
   canvas->GetSkCanvas()->getClipBounds(&last_clip_);
 }
 
 void TestView::SchedulePaintInRect(const gfx::Rect& rect) {
   scheduled_paint_rects_.push_back(rect);
   View::SchedulePaintInRect(rect);
@@ skipping 2545 matching lines @@
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 }
 
 #endif  // VIEWS_COMPOSITOR
 
 }  // namespace views