Replace views::MouseEvent with ui::MouseEvent

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"
@@ skipping 196 matching lines @@
     received_mouse_exit_ = false;
     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 void OnMouseEntered(const MouseEvent& event) OVERRIDE;
-  virtual void OnMouseExited(const MouseEvent& event) 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;
   // 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 ui::Accelerator& accelerator) OVERRIDE;
 
   // OnBoundsChanged.
   bool did_change_bounds_;
   gfx::Rect new_bounds_;
@@ skipping 103 matching lines @@
 
   EXPECT_EQ(v.did_change_bounds_, true);
   EXPECT_EQ(v.new_bounds_, new_rect);
   EXPECT_EQ(v.bounds(), new_rect);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MouseEvent
 ////////////////////////////////////////////////////////////////////////////////
 
-bool TestView::OnMousePressed(const MouseEvent& event) {
+bool TestView::OnMousePressed(const ui::MouseEvent& event) {
   last_mouse_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
   if (delete_on_pressed_)
     delete this;
   return true;
 }
 
-bool TestView::OnMouseDragged(const MouseEvent& event) {
+bool TestView::OnMouseDragged(const ui::MouseEvent& event) {
   last_mouse_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
   return true;
 }
 
-void TestView::OnMouseReleased(const MouseEvent& event) {
+void TestView::OnMouseReleased(const ui::MouseEvent& event) {
   last_mouse_event_type_ = event.type();
   location_.SetPoint(event.x(), event.y());
 }
 
-void TestView::OnMouseEntered(const MouseEvent& event) {
+void TestView::OnMouseEntered(const ui::MouseEvent& event) {
   received_mouse_enter_ = true;
 }
 
-void TestView::OnMouseExited(const MouseEvent& event) {
+void TestView::OnMouseExited(const ui::MouseEvent& event) {
   received_mouse_exit_ = true;
 }
 
 TEST_F(ViewTest, MouseEvent) {
   TestView* v1 = new TestView();
   v1->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
   TestView* v2 = new TestView();
   v2->SetBoundsRect(gfx::Rect(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);
   v1->AddChildView(v2);
 
   v1->Reset();
   v2->Reset();
 
-  MouseEvent pressed(ui::ET_MOUSE_PRESSED,
-                     110,
-                     120,
-                     ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point p1(110, 120);
+  ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, p1, p1,
+                         ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(pressed);
   EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_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_mouse_event_type_, 0);
 
   // Drag event out of bounds. Should still go to v2
   v1->Reset();
   v2->Reset();
-  MouseEvent dragged(ui::ET_MOUSE_DRAGGED,
-                     50,
-                     40,
-                     ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point p2(50, 40);
+  ui::MouseEvent dragged(ui::ET_MOUSE_DRAGGED, p2, p2,
+                         ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMouseDragged(dragged);
   EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_DRAGGED);
   EXPECT_EQ(v2->location_.x(), -50);
   EXPECT_EQ(v2->location_.y(), -60);
   // Make sure v1 did not receive the event
   EXPECT_EQ(v1->last_mouse_event_type_, 0);
 
   // Releasted event out of bounds. Should still go to v2
   v1->Reset();
   v2->Reset();
-  MouseEvent released(ui::ET_MOUSE_RELEASED, 0, 0, 0);
+  ui::MouseEvent released(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), 0);
   root->OnMouseDragged(released);
   EXPECT_EQ(v2->last_mouse_event_type_, ui::ET_MOUSE_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_mouse_event_type_, 0);
 
   widget->CloseNow();
 }
 
@@ skipping 12 matching lines @@
   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);
   v1->AddChildView(v2);
 
   v2->delete_on_pressed_ = true;
-  MouseEvent pressed(ui::ET_MOUSE_PRESSED,
-                     110,
-                     120,
-                     ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point point(110, 120);
+  ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, point, point,
+                         ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(pressed);
   EXPECT_EQ(0, v1->child_count());
 
   widget->CloseNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent
 ////////////////////////////////////////////////////////////////////////////////
 ui::TouchStatus TestView::OnTouchEvent(const TouchEvent& event) {
@@ skipping 600 matching lines @@
 
   v1->Reset();
   v11->Reset();
   v111->Reset();
   v12->Reset();
   v121->Reset();
   v2->Reset();
   v21->Reset();
 
   // Move the mouse in v111.
-  MouseEvent move1(ui::ET_MOUSE_MOVED, 6, 6, 0);
+  gfx::Point p1(6, 6);
+  ui::MouseEvent move1(ui::ET_MOUSE_MOVED, p1, p1, 0);
   root_view->OnMouseMoved(move1);
   EXPECT_TRUE(v111->received_mouse_enter_);
   EXPECT_FALSE(v11->last_mouse_event_type_);
   EXPECT_TRUE(v1->received_mouse_enter_);
 
   v111->Reset();
   v1->Reset();
 
   // Now, move into v121.
-  MouseEvent move2(ui::ET_MOUSE_MOVED, 65, 21, 0);
+  gfx::Point p2(65, 21);
+  ui::MouseEvent move2(ui::ET_MOUSE_MOVED, p2, p2, 0);
   root_view->OnMouseMoved(move2);
   EXPECT_TRUE(v111->received_mouse_exit_);
   EXPECT_TRUE(v121->received_mouse_enter_);
   EXPECT_FALSE(v1->last_mouse_event_type_);
 
   v111->Reset();
   v121->Reset();
 
   // Now, move into v11.
-  MouseEvent move3(ui::ET_MOUSE_MOVED, 1, 1, 0);
+  gfx::Point p3(1, 1);
+  ui::MouseEvent move3(ui::ET_MOUSE_MOVED, p3, p3, 0);
   root_view->OnMouseMoved(move3);
   EXPECT_TRUE(v121->received_mouse_exit_);
   EXPECT_TRUE(v11->received_mouse_enter_);
   EXPECT_FALSE(v1->last_mouse_event_type_);
 
   v121->Reset();
   v11->Reset();
 
   // Move to v21.
-  MouseEvent move4(ui::ET_MOUSE_MOVED, 121, 15, 0);
+  gfx::Point p4(121, 15);
+  ui::MouseEvent move4(ui::ET_MOUSE_MOVED, p4, p4, 0);
   root_view->OnMouseMoved(move4);
   EXPECT_TRUE(v21->received_mouse_enter_);
   EXPECT_FALSE(v2->last_mouse_event_type_);
   EXPECT_TRUE(v11->received_mouse_exit_);
   EXPECT_TRUE(v1->received_mouse_exit_);
 
   v21->Reset();
   v11->Reset();
   v1->Reset();
 
   // Move to v1.
-  MouseEvent move5(ui::ET_MOUSE_MOVED, 21, 0, 0);
+  gfx::Point p5(21, 0);
+  ui::MouseEvent move5(ui::ET_MOUSE_MOVED, p5, p5, 0);
   root_view->OnMouseMoved(move5);
   EXPECT_TRUE(v21->received_mouse_exit_);
   EXPECT_TRUE(v1->received_mouse_enter_);
 
   v21->Reset();
   v1->Reset();
 
   // Now, move into v11.
-  MouseEvent mouse6(ui::ET_MOUSE_MOVED, 15, 15, 0);
+  gfx::Point p6(15, 15);
+  ui::MouseEvent mouse6(ui::ET_MOUSE_MOVED, p6, p6, 0);
   root_view->OnMouseMoved(mouse6);
   EXPECT_TRUE(v11->received_mouse_enter_);
   EXPECT_FALSE(v1->last_mouse_event_type_);
 
   v11->Reset();
   v1->Reset();
 
   // Move back into v1. Although |v1| had already received an ENTER for mouse6,
   // and the mouse remains inside |v1| the whole time, it receives another ENTER
   // when the mouse leaves v11.
-  MouseEvent mouse7(ui::ET_MOUSE_MOVED, 21, 0, 0);
+  gfx::Point p7(21, 0);
+  ui::MouseEvent mouse7(ui::ET_MOUSE_MOVED, p7, p7, 0);
   root_view->OnMouseMoved(mouse7);
   EXPECT_TRUE(v11->received_mouse_exit_);
   EXPECT_FALSE(v1->received_mouse_enter_);
 
   widget->CloseNow();
 }
 
 TEST_F(ViewTest, Textfield) {
   const string16 kText = ASCIIToUTF16("Reality is that which, when you stop "
                                       "believing it, doesn't go away.");
@@ skipping 657 matching lines @@
   // This is owned by test_dialog_.
   View* button_as_view_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ButtonDropDownTest);
 };
 
 // Ensure that regular clicks on the drop down button still work. (i.e. - the
 // click events are processed and the listener gets the click)
 TEST_F(ButtonDropDownTest, RegularClickTest) {
-  MouseEvent press_event(ui::ET_MOUSE_PRESSED, 1, 1, ui::EF_LEFT_MOUSE_BUTTON);
-  MouseEvent release_event(ui::ET_MOUSE_RELEASED, 1, 1,
-                           ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point point(1, 1);
+  ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, point, point,
+                             ui::EF_LEFT_MOUSE_BUTTON);
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, point, point,
+                               ui::EF_LEFT_MOUSE_BUTTON);
   button_as_view_->OnMousePressed(press_event);
   button_as_view_->OnMouseReleased(release_event);
   EXPECT_EQ(test_dialog_->last_pressed_button_, test_dialog_->button_drop_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // View hierarchy / Visibility changes
 ////////////////////////////////////////////////////////////////////////////////
 /*
 TEST_F(ViewTest, ChangeVisibility) {
@@ skipping 235 matching lines @@
   // Rotate |v1| counter-clockwise.
   ui::Transform transform(v1->GetTransform());
   RotateCounterclockwise(&transform);
   transform.SetTranslateY(500.0f);
   v1->SetTransform(transform);
 
   // |v2| now occupies (100, 200) to (200, 400) in |root|.
   v1->Reset();
   v2->Reset();
 
-  MouseEvent pressed(ui::ET_MOUSE_PRESSED,
-                     110, 210,
-                     ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point p1(110, 210);
+  ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, p1, p1,
+                         ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(pressed);
   EXPECT_EQ(0, v1->last_mouse_event_type_);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v2->last_mouse_event_type_);
   EXPECT_EQ(190, v2->location_.x());
   EXPECT_EQ(10, v2->location_.y());
 
-  MouseEvent released(ui::ET_MOUSE_RELEASED, 0, 0, 0);
+  ui::MouseEvent released(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), 0);
   root->OnMouseReleased(released);
 
   // Now rotate |v2| inside |v1| clockwise.
   transform = v2->GetTransform();
   RotateClockwise(&transform);
   transform.SetTranslateX(100.0f);
   v2->SetTransform(transform);
 
   // Now, |v2| occupies (100, 100) to (200, 300) in |v1|, and (100, 300) to
   // (300, 400) in |root|.
 
   v1->Reset();
   v2->Reset();
 
-  MouseEvent p2(ui::ET_MOUSE_PRESSED,
-                110, 320,
-                ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point point2(110, 320);
+  ui::MouseEvent p2(ui::ET_MOUSE_PRESSED, point2, point2,
+                    ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(p2);
   EXPECT_EQ(0, v1->last_mouse_event_type_);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v2->last_mouse_event_type_);
   EXPECT_EQ(10, v2->location_.x());
   EXPECT_EQ(20, v2->location_.y());
 
   root->OnMouseReleased(released);
 
   v1->SetTransform(ui::Transform());
   v2->SetTransform(ui::Transform());
@@ skipping 12 matching lines @@
   transform = v2->GetTransform();
   transform.SetScale(0.8f, 0.5f);
   v2->SetTransform(transform);
 
   // |v3| occupies (108, 105) to (132, 115) in |root|.
 
   v1->Reset();
   v2->Reset();
   v3->Reset();
 
-  MouseEvent p3(ui::ET_MOUSE_PRESSED,
-                112, 110,
-                ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point point(112, 110);
+  ui::MouseEvent p3(ui::ET_MOUSE_PRESSED, point, point,
+                    ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(p3);
 
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v3->last_mouse_event_type_);
   EXPECT_EQ(10, v3->location_.x());
   EXPECT_EQ(25, v3->location_.y());
 
   root->OnMouseReleased(released);
 
   v1->SetTransform(ui::Transform());
   v2->SetTransform(ui::Transform());
@@ skipping 13 matching lines @@
   transform.ConcatScale(0.8f, 0.5f);
   v3->SetTransform(transform);
 
   // Translate |v2| with respect to |v1|.
   transform = v2->GetTransform();
   transform.SetTranslate(10, 10);
   v2->SetTransform(transform);
 
   // |v3| now occupies (120, 120) to (144, 130) in |root|.
 
-  MouseEvent p4(ui::ET_MOUSE_PRESSED,
-                124, 125,
-                ui::EF_LEFT_MOUSE_BUTTON);
+  gfx::Point point3(124, 125);
+  ui::MouseEvent p4(ui::ET_MOUSE_PRESSED, point3, point3,
+                    ui::EF_LEFT_MOUSE_BUTTON);
   root->OnMousePressed(p4);
 
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, v3->last_mouse_event_type_);
   EXPECT_EQ(10, v3->location_.x());
   EXPECT_EQ(25, v3->location_.y());
 
   root->OnMouseReleased(released);
 
   widget->CloseNow();
 }
@@ skipping 1178 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