Touch to Mouse conversion validation of views::GestureManager

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.
 
+// Enable testing code in views/event/event.h by turning on TESTING macro.
+#define TESTING 1
+
 #include <map>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/compositor/test_compositor.h"
 #include "ui/gfx/compositor/test_texture.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/transform.h"
 #include "views/background.h"
 #include "views/controls/button/button_dropdown.h"
 #include "views/controls/button/checkbox.h"
 #include "views/controls/native/native_view_host.h"
 #include "views/controls/scroll_view.h"
 #include "views/controls/textfield/textfield.h"
 #include "views/events/event.h"
 #include "views/focus/accelerator_handler.h"
 #include "views/focus/view_storage.h"
+#include "views/test/test_event_utils.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(OS_WIN)
 #include "views/test/test_views_delegate.h"
@@ skipping 225 matching lines @@
 // 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;
 };
 
+// Test GestureManager for touch to mouse conversion.
+class TestGestureManager : public GestureManager {
+ public:
+  // Reset all test state.
+  void Reset() {
+    last_touch_event_ = 0;
+    last_view_ = NULL;
+    previously_handled_flag_ = false;
+    dispatched_synthetic_event_ = false;
+  }
+
+  bool ProcessTouchEventForGesture(const TouchEvent& event,
+                                   View* source,
+                                   ui::TouchStatus status);
+  TestGestureManager();
+
+  bool previously_handled_flag_;
+  int last_touch_event_;
+  View *last_view_;
+  bool dispatched_synthetic_event_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestGestureManager);
+};
+
+// A TouchEvent with filled in native event part to ease touch to
+// mouse conversion.
+class MockTouchEvent : public TouchEvent {
+ public:
+  // Create a new touch event.
+  MockTouchEvent(ui::EventType type,
+                 int x,
+                 int y,
+                 int flags,
+                 int touch_id,
+                 float radius_x,
+                 float radius_y,
+                 float angle,
+                 float force);
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // OnBoundsChanged
 ////////////////////////////////////////////////////////////////////////////////
 
 void TestView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   did_change_bounds_ = true;
   new_bounds_ = bounds();
 }
 
 TEST_F(ViewTest, OnBoundsChanged) {
@@ skipping 243 matching lines @@
   // 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);
 
   widget->CloseNow();
 }
 
+bool TestGestureManager::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;
+  return dispatched_synthetic_event_ =
+      GestureManager::ProcessTouchEventForGesture(event, source, status);
+}
+
+TestGestureManager::TestGestureManager() {
+}
+
+MockTouchEvent::MockTouchEvent(ui::EventType type,
+                               int x,
+                               int y,
+                               int flags,
+                               int touch_id,
+                               float radius_x,
+                               float radius_y,
+                               float angle,
+                               float force)
+      : TouchEvent(type, x, y, flags, touch_id, radius_x, radius_y,
+                   angle, force) {
+#if defined(USE_X11)
+  // TODO(Gajen): Provide support for non-X platforms.
+
+  // Set NativeEvent and its internal fields.
+  base::NativeEvent native_event = views::GetNativeEventForTesting();
+  views::SetNativeEventLocationForTesting(native_event, x, y);
+#endif
+  set_native_event(native_event);
+}
+
+// Tests Real GestureManager instead of the mock one and validates Touch event
+// to Mouse conversion when view hierarchy doesn't handle touch events.
+#if defined(USE_X11)
+// TODO(Gajen): Add support for non-X platforms.
+TEST_F(ViewTest, TouchToMouse) {
+  TestGestureManager gm;
+
+  TestView* v1 = new TestViewIgnoreTouch();
+  v1->SetBounds(0, 0, 300, 300);
+
+  TestView* v2 = new TestViewIgnoreTouch();
+  v2->SetBounds(100, 100, 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);
+
+  // Test press.
+  v1->Reset();
+  v2->Reset();
+  gm.Reset();
+
+  MockTouchEvent pressed(ui::ET_TOUCH_PRESSED,
+                         110,
+                         120,
+                         0, /* no flags */
+                         0, /* first finger touch */
+                         1.0, 0.0, 1.0, 0.0);
+  root->OnTouchEvent(pressed);
+
+  EXPECT_EQ(v2->last_touch_event_type_, 0);
+  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 v1 and v2 didn't handled the 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);
+  EXPECT_EQ(gm.dispatched_synthetic_event_, true);
+
+  // Check GestureManager converted Touch event to Mouse and propogates to v2
+  // but v1.
+  EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_PRESSED);
+  EXPECT_EQ(v2->location_.x(), 10);
+  EXPECT_EQ(v2->location_.y(), 20);
+  EXPECT_EQ(v1->last_mouse_event_type_, 0);
+  EXPECT_EQ(v1->location_.x(), 0);
+  EXPECT_EQ(v1->location_.y(), 0);
+  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);
@@ skipping 2546 matching lines @@
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 }
 
 #endif  // VIEWS_COMPOSITOR
 
 }  // namespace views