Replace views::MouseEvent with ui::MouseEvent

ui/views/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/view.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 746 matching lines @@
       continue;
 
     gfx::Point point_in_child_coords(point);
     ConvertPointToTarget(this, child, &point_in_child_coords);
     if (child->HitTestPoint(point_in_child_coords))
       return child->GetEventHandlerForPoint(point_in_child_coords);
   }
   return this;
 }
 
-gfx::NativeCursor View::GetCursor(const MouseEvent& event) {
+gfx::NativeCursor View::GetCursor(const ui::MouseEvent& event) {
 #if defined(OS_WIN) && !defined(USE_AURA)
   static HCURSOR arrow = LoadCursor(NULL, IDC_ARROW);
   return arrow;
 #else
   return gfx::kNullCursor;
 #endif
 }
 
 bool View::HitTestPoint(const gfx::Point& point) const {
   return HitTestRect(gfx::Rect(point, gfx::Size(1, 1)));
@@ skipping 17 matching lines @@
       return RectInRegion(rgn, &r) != 0;
 #endif
     }
     // No mask, but inside our bounds.
     return true;
   }
   // Outside our bounds.
   return false;
 }
 
-bool View::OnMousePressed(const MouseEvent& event) {
+bool View::OnMousePressed(const ui::MouseEvent& event) {
   return false;
 }
 
-bool View::OnMouseDragged(const MouseEvent& event) {
+bool View::OnMouseDragged(const ui::MouseEvent& event) {
   return false;
 }
 
-void View::OnMouseReleased(const MouseEvent& event) {
+void View::OnMouseReleased(const ui::MouseEvent& event) {
 }
 
 void View::OnMouseCaptureLost() {
 }
 
-void View::OnMouseMoved(const MouseEvent& event) {
+void View::OnMouseMoved(const ui::MouseEvent& event) {
 }
 
-void View::OnMouseEntered(const MouseEvent& event) {
+void View::OnMouseEntered(const ui::MouseEvent& event) {
 }
 
-void View::OnMouseExited(const MouseEvent& event) {
+void View::OnMouseExited(const ui::MouseEvent& event) {
 }
 
 ui::TouchStatus View::OnTouchEvent(const TouchEvent& event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
 ui::GestureStatus View::OnGestureEvent(const GestureEvent& event) {
   return ui::GESTURE_STATUS_UNKNOWN;
 }
 
@@ skipping 1057 matching lines @@
 
   SchedulePaint();
 
   Widget* widget = GetWidget();
   if (widget)
     widget->UpdateRootLayers();
 }
 
 // Input -----------------------------------------------------------------------
 
-bool View::ProcessMousePressed(const MouseEvent& event, DragInfo* drag_info) {
+bool View::ProcessMousePressed(const ui::MouseEvent& event, DragInfo* drag_info) {
   int drag_operations =
       (enabled_ && event.IsOnlyLeftMouseButton() &&
        HitTestPoint(event.location())) ?
        GetDragOperations(event.location()) : 0;
   ContextMenuController* context_menu_controller = event.IsRightMouseButton() ?
       context_menu_controller_ : 0;
 
   const bool enabled = enabled_;
   const bool result = OnMousePressed(event);
   // WARNING: we may have been deleted, don't use any View variables.
 
   if (!enabled)
     return result;
 
   if (drag_operations != ui::DragDropTypes::DRAG_NONE) {
     drag_info->PossibleDrag(event.location());
     return true;
   }
   return !!context_menu_controller || result;
 }
 
-bool View::ProcessMouseDragged(const MouseEvent& event, DragInfo* drag_info) {
+bool View::ProcessMouseDragged(const ui::MouseEvent& event, DragInfo* drag_info) {
   // Copy the field, that way if we're deleted after drag and drop no harm is
   // done.
   ContextMenuController* context_menu_controller = context_menu_controller_;
   const bool possible_drag = drag_info->possible_drag;
   if (possible_drag && ExceededDragThreshold(
       drag_info->start_pt.x() - event.x(),
       drag_info->start_pt.y() - event.y())) {
     if (!drag_controller_ ||
         drag_controller_->CanStartDragForView(
             this, drag_info->start_pt, event.location()))
       DoDrag(event, drag_info->start_pt);
   } else {
     if (OnMouseDragged(event))
       return true;
     // Fall through to return value based on context menu controller.
   }
   // WARNING: we may have been deleted.
   return (context_menu_controller != NULL) || possible_drag;
 }
 
-void View::ProcessMouseReleased(const MouseEvent& event) {
+void View::ProcessMouseReleased(const ui::MouseEvent& event) {
   if (context_menu_controller_ && event.IsOnlyRightMouseButton()) {
     // Assume that if there is a context menu controller we won't be deleted
     // from mouse released.
     gfx::Point location(event.location());
     OnMouseReleased(event);
     if (HitTestPoint(location)) {
       ConvertPointToScreen(this, &location);
       ShowContextMenu(location, true);
     }
   } else {
@@ skipping 156 matching lines @@
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   GetWidget()->RunShellDrag(this, data, widget_location, drag_operations);
   return true;
 #else
   return false;
 #endif  // !defined(OS_MACOSX)
 }
 
 }  // namespace views