Rid the world of the last of views::Event types: TouchEvent, GestureEvent, MouseWheelEvent, ScrollE…

ui/views/view_unittest.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 <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/accelerators/accelerator.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/event.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.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/path.h"
 #include "ui/gfx/transform.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/button/button_dropdown.h"
 #include "ui/views/controls/button/checkbox.h"
 #include "ui/views/controls/native/native_view_host.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/controls/textfield/textfield.h"
-#include "ui/views/events/event.h"
 #include "ui/views/focus/accelerator_handler.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/view.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/window/dialog_delegate.h"
 
 #if defined(OS_WIN)
@@ skipping 138 matching lines @@
     view->ReorderChildView(view_b, a);
   }
 
   if (!view->layer() && base::RandDouble() < 0.1)
     view->SetPaintToLayer(true);
 
   if (base::RandDouble() < 0.1)
     view->SetVisible(!view->visible());
 }
 
+// Convenience to make constructing a GestureEvent simpler.
+class GestureEventForTest : public ui::GestureEvent {
+ public:
+  GestureEventForTest(ui::EventType type, int x, int y, int flags)
+      : GestureEvent(type, x, y, flags, base::TimeDelta(),
+                     ui::GestureEventDetails(type, 0.0f, 0.0f), 0) {
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(GestureEventForTest);
+};
+
 }  // namespace
 
 namespace views {
 
 typedef ViewsTestBase ViewTest;
 
 // A derived class for testing purpose.
 class TestView : public View {
  public:
   TestView() : View(), delete_on_pressed_(false), in_touch_sequence_(false) {}
@@ skipping 13 matching lines @@
     last_clip_.setEmpty();
     accelerator_count_map_.clear();
   }
 
   virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE;
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
-  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
+  virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event) OVERRIDE;
   // Ignores GestureEvent by default.
-  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event) OVERRIDE;
+  virtual ui::GestureStatus OnGestureEvent(
+      const ui::GestureEvent& event) OVERRIDE;
   virtual void Paint(gfx::Canvas* canvas) OVERRIDE;
   virtual void SchedulePaintInRect(const gfx::Rect& rect) OVERRIDE;
   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
 
   // OnBoundsChanged.
   bool did_change_bounds_;
   gfx::Rect new_bounds_;
 
   // MouseEvent.
   int last_mouse_event_type_;
@@ skipping 21 matching lines @@
   std::map<ui::Accelerator, int> accelerator_count_map_;
 };
 
 // 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;
+  virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event) OVERRIDE;
 };
 
 // A view subclass that consumes all Gesture events for testing purposes.
 class TestViewConsumeGesture : public TestView {
  public:
   TestViewConsumeGesture() : TestView() {}
   virtual ~TestViewConsumeGesture() {}
 
  protected:
-  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event) OVERRIDE {
+  virtual ui::GestureStatus OnGestureEvent(
+      const ui::GestureEvent& event) OVERRIDE {
     last_gesture_event_type_ = event.type();
     location_.SetPoint(event.x(), event.y());
     return ui::GESTURE_STATUS_CONSUMED;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestViewConsumeGesture);
 };
 
 // A view subclass that ignores all Gesture events.
 class TestViewIgnoreGesture: public TestView {
  public:
   TestViewIgnoreGesture() : TestView() {}
   virtual ~TestViewIgnoreGesture() {}
 
  private:
-  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event) OVERRIDE {
+  virtual ui::GestureStatus OnGestureEvent(
+      const ui::GestureEvent& event) OVERRIDE {
     return ui::GESTURE_STATUS_UNKNOWN;
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestViewIgnoreGesture);
 };
 
 // A view subclass that ignores all scroll-gesture events, but consume all other
 // gesture events.
 class TestViewIgnoreScrollGestures : public TestViewConsumeGesture {
  public:
   TestViewIgnoreScrollGestures() {}
   virtual ~TestViewIgnoreScrollGestures() {}
 
  private:
-  virtual ui::GestureStatus OnGestureEvent(const GestureEvent& event) OVERRIDE {
+  virtual ui::GestureStatus OnGestureEvent(
+      const ui::GestureEvent& event) OVERRIDE {
     if (event.IsScrollGestureEvent())
       return ui::GESTURE_STATUS_UNKNOWN;
     return TestViewConsumeGesture::OnGestureEvent(event);
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestViewIgnoreScrollGestures);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // OnBoundsChanged
@@ skipping 134 matching lines @@
                          ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(pressed);
   EXPECT_EQ(0, v1->child_count());
 
   widget->CloseNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent
 ////////////////////////////////////////////////////////////////////////////////
-ui::TouchStatus TestView::OnTouchEvent(const TouchEvent& event) {
+ui::TouchStatus TestView::OnTouchEvent(const ui::TouchEvent& event) {
   last_touch_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
   if (!in_touch_sequence_) {
     if (event.type() == ui::ET_TOUCH_PRESSED) {
       in_touch_sequence_ = true;
       return ui::TOUCH_STATUS_START;
     }
   } else {
     if (event.type() == ui::ET_TOUCH_RELEASED) {
       in_touch_sequence_ = false;
       return ui::TOUCH_STATUS_END;
     }
     return ui::TOUCH_STATUS_CONTINUE;
   }
   return last_touch_event_was_handled_ ? ui::TOUCH_STATUS_CONTINUE :
                                          ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::TouchStatus TestViewIgnoreTouch::OnTouchEvent(const TouchEvent& event) {
+ui::TouchStatus TestViewIgnoreTouch::OnTouchEvent(const ui::TouchEvent& event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
 TEST_F(ViewTest, TouchEvent) {
   TestView* v1 = new TestView();
   v1->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
   TestView* v2 = new TestView();
   v2->SetBoundsRect(gfx::Rect(100, 100, 100, 100));
 
@@ skipping 12 matching lines @@
   v2->AddChildView(v3);
 
   // |v3| completely obscures |v2|, but all the touch events on |v3| should
   // reach |v2| because |v3| doesn't process any touch events.
 
   // Make sure if none of the views handle the touch event, the gesture manager
   // does.
   v1->Reset();
   v2->Reset();
 
-  TouchEvent unhandled(ui::ET_TOUCH_MOVED,
-                       400,
-                       400,
-                       0, /* no flags */
-                       0, /* first finger touch */
-                       1.0, 0.0, 1.0, 0.0);
+  ui::TestTouchEvent unhandled(ui::ET_TOUCH_MOVED,
+                               400, 400,
+                               0, /* no flags */
+                               0, /* first finger touch */
+                               1.0, 0.0, 1.0, 0.0);
   root->OnTouchEvent(unhandled);
 
   EXPECT_EQ(v1->last_touch_event_type_, 0);
   EXPECT_EQ(v2->last_touch_event_type_, 0);
 
   // Test press, drag, release touch sequence.
   v1->Reset();
   v2->Reset();
 
-  TouchEvent pressed(ui::ET_TOUCH_PRESSED,
-                     110,
-                     120,
-                     0, /* no flags */
-                     0, /* first finger touch */
-                     1.0, 0.0, 1.0, 0.0);
+  ui::TestTouchEvent 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;
   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);
 
   // 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);
+  ui::TestTouchEvent dragged(ui::ET_TOUCH_MOVED,
+                             50, 40,
+                             0, /* no flags */
+                             0, /* first finger touch */
+                             1.0, 0.0, 1.0, 0.0);
 
   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);
 
   // 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);
+  ui::TestTouchEvent released(ui::ET_TOUCH_RELEASED, 0, 0,
+                              0, /* no flags */
+                              0, /* first finger */
+                              1.0, 0.0, 1.0, 0.0);
   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);
 
   widget->CloseNow();
 }
 
-ui::GestureStatus TestView::OnGestureEvent(const GestureEvent& event) {
+ui::GestureStatus TestView::OnGestureEvent(const ui::GestureEvent& event) {
   return ui::GESTURE_STATUS_UNKNOWN;
 }
 
 TEST_F(ViewTest, GestureEvent) {
   // Views hierarchy for non delivery of GestureEvent.
   TestView* v1 = new TestViewConsumeGesture();
   v1->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
   TestView* v2 = new TestViewConsumeGesture();
   v2->SetBoundsRect(gfx::Rect(100, 100, 100, 100));
@@ skipping 2778 matching lines @@
   // Set to non default value.
   v->layer()->set_scale_content(false);
   scoped_ptr<ui::Layer> old_layer(v->RecreateLayer());
   ui::Layer* new_layer = v->layer();
   EXPECT_FALSE(new_layer->scale_content());
 }
 
 #endif  // USE_AURA
 
 }  // namespace views