Replace views::MouseEvent with ui::MouseEvent

ui/views/widget/root_view.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 "ui/views/widget/root_view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 13 matching lines @@
 namespace {
 
 enum EventType {
   EVENT_ENTER,
   EVENT_EXIT
 };
 
 // |view| is the view receiving |event|. This function sends the event to all
 // the Views up the hierarchy that has |notify_enter_exit_on_child_| flag turned
 // on, but does not contain |sibling|.
-void NotifyEnterExitOfDescendant(const MouseEvent& event,
+void NotifyEnterExitOfDescendant(const ui::MouseEvent& event,
                                  EventType type,
                                  View* view,
                                  View* sibling) {
   for (View* p = view->parent(); p; p = p->parent()) {
     if (!p->notify_enter_exit_on_child())
       continue;
     if (sibling && p->Contains(sibling))
         break;
     if (type == EVENT_ENTER)
       p->OnMouseEntered(event);
@@ skipping 145 matching lines @@
   if (layer()) {
     layer()->SchedulePaint(rect);
   } else {
     gfx::Rect xrect = ConvertRectToParent(rect);
     gfx::Rect invalid_rect = GetLocalBounds().Intersect(xrect);
     if (!invalid_rect.IsEmpty())
       widget_->SchedulePaintInRect(invalid_rect);
   }
 }
 
-bool RootView::OnMousePressed(const MouseEvent& event) {
+bool RootView::OnMousePressed(const ui::MouseEvent& event) {
   UpdateCursor(event);
   SetMouseLocationAndFlags(event);
 
   // If mouse_pressed_handler_ is non null, we are currently processing
   // a pressed -> drag -> released session. In that case we send the
   // event to mouse_pressed_handler_
   if (mouse_pressed_handler_) {
-    MouseEvent mouse_pressed_event(event, this, mouse_pressed_handler_);
+    ui::MouseEvent mouse_pressed_event(event, static_cast<View*>(this),
+                                       mouse_pressed_handler_);
     drag_info_.Reset();
     mouse_pressed_handler_->ProcessMousePressed(mouse_pressed_event,
                                                 &drag_info_);
     return true;
   }
   DCHECK(!explicit_mouse_handler_);
 
   bool hit_disabled_view = false;
   // Walk up the tree until we find a view that wants the mouse event.
   for (mouse_pressed_handler_ = GetEventHandlerForPoint(event.location());
        mouse_pressed_handler_ && (mouse_pressed_handler_ != this);
        mouse_pressed_handler_ = mouse_pressed_handler_->parent()) {
     DVLOG(1) << "OnMousePressed testing "
         << mouse_pressed_handler_->GetClassName();
     if (!mouse_pressed_handler_->enabled()) {
       // Disabled views should eat events instead of propagating them upwards.
       hit_disabled_view = true;
       break;
     }
 
     // See if this view wants to handle the mouse press.
-    MouseEvent mouse_pressed_event(event, this, mouse_pressed_handler_);
+    ui::MouseEvent mouse_pressed_event(event, static_cast<View*>(this),
+                                       mouse_pressed_handler_);
 
     // Remove the double-click flag if the handler is different than the
     // one which got the first click part of the double-click.
     if (mouse_pressed_handler_ != last_click_handler_)
       mouse_pressed_event.set_flags(event.flags() & ~ui::EF_IS_DOUBLE_CLICK);
 
     drag_info_.Reset();
     bool handled = mouse_pressed_handler_->ProcessMousePressed(
         mouse_pressed_event, &drag_info_);
 
@@ skipping 25 matching lines @@
   // entire hierarchy (even as a single-click when sent to a different view),
   // it must be marked as handled to avoid anything happening from default
   // processing if it the first click-part was handled by us.
   if (last_click_handler_ && (event.flags() & ui::EF_IS_DOUBLE_CLICK))
     hit_disabled_view = true;
 
   last_click_handler_ = NULL;
   return hit_disabled_view;
 }
 
-bool RootView::OnMouseDragged(const MouseEvent& event) {
+bool RootView::OnMouseDragged(const ui::MouseEvent& event) {
   if (mouse_pressed_handler_) {
     SetMouseLocationAndFlags(event);
 
-    MouseEvent mouse_event(event, this, mouse_pressed_handler_);
+    ui::MouseEvent mouse_event(event, static_cast<View*>(this),
+                               mouse_pressed_handler_);
     return mouse_pressed_handler_->ProcessMouseDragged(mouse_event,
                                                        &drag_info_);
   }
   return false;
 }
 
-void RootView::OnMouseReleased(const MouseEvent& event) {
+void RootView::OnMouseReleased(const ui::MouseEvent& event) {
   UpdateCursor(event);
 
   if (mouse_pressed_handler_) {
-    MouseEvent mouse_released(event, this, mouse_pressed_handler_);
+    ui::MouseEvent mouse_released(event, static_cast<View*>(this),
+                                  mouse_pressed_handler_);
     // We allow the view to delete us from ProcessMouseReleased. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
     SetMouseHandler(NULL);
     mouse_pressed_handler->ProcessMouseReleased(mouse_released);
     // WARNING: we may have been deleted.
   }
 }
 
 void RootView::OnMouseCaptureLost() {
   // TODO: this likely needs to reset touch handler too.
 
   if (mouse_pressed_handler_ || gesture_handler_) {
     // Synthesize a release event for UpdateCursor.
     if (mouse_pressed_handler_) {
-      MouseEvent release_event(ui::ET_MOUSE_RELEASED, last_mouse_event_x_,
-                               last_mouse_event_y_, last_mouse_event_flags_);
+      gfx::Point last_point(last_mouse_event_x_, last_mouse_event_y_);
+      ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED,
+                                   last_point, last_point,
+                                   last_mouse_event_flags_);
       UpdateCursor(release_event);
     }
     // We allow the view to delete us from OnMouseCaptureLost. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
     View* gesture_handler = gesture_handler_;
     SetMouseHandler(NULL);
     if (mouse_pressed_handler)
       mouse_pressed_handler->OnMouseCaptureLost();
     else
       gesture_handler->OnMouseCaptureLost();
     // WARNING: we may have been deleted.
   }
 }
 
-void RootView::OnMouseMoved(const MouseEvent& event) {
+void RootView::OnMouseMoved(const ui::MouseEvent& event) {
   View* v = GetEventHandlerForPoint(event.location());
   // Find the first enabled view, or the existing move handler, whichever comes
   // first.  The check for the existing handler is because if a view becomes
   // disabled while handling moves, it's wrong to suddenly send ET_MOUSE_EXITED
   // and ET_MOUSE_ENTERED events, because the mouse hasn't actually exited yet.
   while (v && !v->enabled() && (v != mouse_move_handler_))
     v = v->parent();
   if (v && v != this) {
     if (v != mouse_move_handler_) {
       if (mouse_move_handler_ != NULL &&
           (!mouse_move_handler_->notify_enter_exit_on_child() ||
            !mouse_move_handler_->Contains(v))) {
         mouse_move_handler_->OnMouseExited(event);
         NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, v);
       }
       View* old_handler = mouse_move_handler_;
       mouse_move_handler_ = v;
-      MouseEvent entered_event(event, this, mouse_move_handler_);
+      ui::MouseEvent entered_event(event, static_cast<View*>(this),
+                                   mouse_move_handler_);
       if (!mouse_move_handler_->notify_enter_exit_on_child() ||
           !mouse_move_handler_->Contains(old_handler)) {
         mouse_move_handler_->OnMouseEntered(entered_event);
         NotifyEnterExitOfDescendant(entered_event, EVENT_ENTER, v,
             old_handler);
       }
     }
-    MouseEvent moved_event(event, this, mouse_move_handler_);
+    ui::MouseEvent moved_event(event, static_cast<View*>(this),
+                               mouse_move_handler_);
     mouse_move_handler_->OnMouseMoved(moved_event);
     if (!(moved_event.flags() & ui::EF_IS_NON_CLIENT))
       widget_->SetCursor(mouse_move_handler_->GetCursor(moved_event));
   } else if (mouse_move_handler_ != NULL) {
     mouse_move_handler_->OnMouseExited(event);
     NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, v);
     // On Aura the non-client area extends slightly outside the root view for
     // some windows.  Let the non-client cursor handling code set the cursor
     // as we do above.
     if (!(event.flags() & ui::EF_IS_NON_CLIENT))
       widget_->SetCursor(gfx::kNullCursor);
   }
 }
 
-void RootView::OnMouseExited(const MouseEvent& event) {
+void RootView::OnMouseExited(const ui::MouseEvent& event) {
   if (mouse_move_handler_ != NULL) {
     mouse_move_handler_->OnMouseExited(event);
     NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, NULL);
     mouse_move_handler_ = NULL;
   }
 }
 
 bool RootView::OnMouseWheel(const MouseWheelEvent& event) {
   bool consumed = false;
   for (View* v = GetFocusManager()->GetFocusedView();
@@ skipping 202 matching lines @@
   View::CalculateOffsetToAncestorWithLayer(offset, layer_parent);
   if (!layer())
     widget_->CalculateOffsetToAncestorWithLayer(offset, layer_parent);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, private:
 
 // Input -----------------------------------------------------------------------
 
-void RootView::UpdateCursor(const MouseEvent& event) {
+void RootView::UpdateCursor(const ui::MouseEvent& event) {
   if (!(event.flags() & ui::EF_IS_NON_CLIENT)) {
     View* v = GetEventHandlerForPoint(event.location());
-    widget_->SetCursor(v->GetCursor(MouseEvent(event, this, v)));
+    ui::MouseEvent me(event, static_cast<View*>(this), v);
+    widget_->SetCursor(v->GetCursor(me));
   }
 }
 
-void RootView::SetMouseLocationAndFlags(const MouseEvent& event) {
+void RootView::SetMouseLocationAndFlags(const ui::MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
 }  // namespace internal
 }  // namespace views