Replace views::MouseEvent with ui::MouseEvent

chrome/browser/ui/views/tabs/tab_strip.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 "chrome/browser/ui/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 276 matching lines @@
   // image.
   void set_background_offset(const gfx::Point& offset) {
     background_offset_ = offset;
   }
 
  protected:
   // Overridden from views::View:
   virtual bool HasHitTestMask() const OVERRIDE;
   virtual void GetHitTestMask(gfx::Path* path) const OVERRIDE;
 #if defined(OS_WIN) && !defined(USE_AURA)
-  void OnMouseReleased(const views::MouseEvent& event) OVERRIDE;
+  void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
 #endif
   virtual ui::GestureStatus OnGestureEvent(
       const views::GestureEvent& event) OVERRIDE;
   void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
  private:
   bool ShouldUseNativeFrame() const;
   gfx::ImageSkia GetBackgroundImage(views::CustomButton::ButtonState state,
                                     ui::ScaleFactor scale_factor) const;
   gfx::ImageSkia GetImageForState(views::CustomButton::ButtonState state,
@@ skipping 38 matching lines @@
   path->lineTo(w - 4, 4);
   path->lineTo(w, 16);
   path->lineTo(w - 1, 17);
   path->lineTo(7, 17);
   path->lineTo(4, 13);
   path->lineTo(0, 1);
   path->close();
 }
 
 #if defined(OS_WIN) && !defined(USE_AURA)
-void NewTabButton::OnMouseReleased(const views::MouseEvent& event) {
+void NewTabButton::OnMouseReleased(const ui::MouseEvent& event) {
   if (event.IsOnlyRightMouseButton()) {
     gfx::Point point(event.x(), event.y());
     views::View::ConvertPointToScreen(this, &point);
     ui::ShowSystemMenu(GetWidget()->GetNativeView(), point.x(), point.y());
     SetState(BS_NORMAL);
     return;
   }
   views::ImageButton::OnMouseReleased(event);
 }
 #endif
@@ skipping 182 matching lines @@
 
   views::Widget* widget = tabstrip_->GetWidget();
   // This can be null during shutdown. See http://crbug.com/42737.
   if (!widget)
     return;
 
   widget->ResetLastMouseMoveFlag();
   gfx::Point position = gfx::Screen::GetCursorScreenPoint();
   views::View* root_view = widget->GetRootView();
   views::View::ConvertPointFromScreen(root_view, &position);
-  views::MouseEvent mouse_event(
-      ui::ET_MOUSE_MOVED, position.x(), position.y(), ui::EF_IS_SYNTHESIZED);
+  ui::MouseEvent mouse_event(ui::ET_MOUSE_MOVED,
+                             position, position,
+                             ui::EF_IS_SYNTHESIZED);
   root_view->OnMouseMoved(mouse_event);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const char TabStrip::kViewClassName[] = "TabStrip";
 
 // static
@@ skipping 445 matching lines @@
   // Use MOVE_VISIBILE_TABS in the following conditions:
   // . Mouse event generated from touch and the left button is down (the right
   //   button corresponds to a long press, which we want to reorder).
   // . Gesture begin and control key isn't down.
   // . Real mouse event and control is down. This is mostly for testing.
   DCHECK(event.type() == ui::ET_MOUSE_PRESSED ||
          event.type() == ui::ET_GESTURE_BEGIN);
   if (adjust_layout_ &&
       ((event.type() == ui::ET_MOUSE_PRESSED &&
         (((event.flags() & ui::EF_FROM_TOUCH) &&
-          static_cast<const views::MouseEvent&>(event).IsLeftMouseButton()) ||
+          static_cast<const ui::MouseEvent&>(event).IsLeftMouseButton()) ||
          (!(event.flags() & ui::EF_FROM_TOUCH) &&
-          static_cast<const views::MouseEvent&>(event).IsControlDown()))) ||
+          static_cast<const ui::MouseEvent&>(event).IsControlDown()))) ||
        (event.type() == ui::ET_GESTURE_BEGIN && !event.IsControlDown()))) {
     move_behavior = TabDragController::MOVE_VISIBILE_TABS;
   }
 #if defined(OS_WIN)
   // It doesn't make sense to drag tabs out on metro.
   if (base::win::IsMetroProcess())
     detach_behavior = TabDragController::NOT_DETACHABLE;
 #endif
   // Gestures don't automatically do a capture. We don't allow multiple drags at
   // the same time, so we explicitly capture.
@@ skipping 38 matching lines @@
 }
 
 void TabStrip::ClickActiveTab(const BaseTab* tab) const {
   DCHECK(IsActiveTab(tab));
   int index = GetModelIndexOfBaseTab(tab);
   if (controller() && IsValidModelIndex(index))
     controller()->ClickActiveTab(index);
 }
 
 void TabStrip::OnMouseEventInTab(views::View* source,
-                                 const views::MouseEvent& event) {
+                                 const ui::MouseEvent& event) {
   UpdateLayoutTypeFromMouseEvent(source, event);
 }
 
 bool TabStrip::ShouldPaintTab(const BaseTab* tab, gfx::Rect* clip) {
   // Only touch layout needs to restrict the clip.
   if (!touch_layout_.get())
     return true;
 
   int index = GetModelIndexOfBaseTab(tab);
   if (index == -1)
@@ skipping 278 matching lines @@
         return tab_at(index);
       } else {
         return NULL;
       }
     }
   }
 
   return View::GetViewByID(view_id);
 }
 
-bool TabStrip::OnMousePressed(const views::MouseEvent& event) {
+bool TabStrip::OnMousePressed(const ui::MouseEvent& event) {
   UpdateLayoutTypeFromMouseEvent(this, event);
   // We can't return true here, else clicking in an empty area won't drag the
   // window.
   return false;
 }
 
-bool TabStrip::OnMouseDragged(const views::MouseEvent& event) {
+bool TabStrip::OnMouseDragged(const ui::MouseEvent& event) {
   ContinueDrag(this, event.location());
   return true;
 }
 
-void TabStrip::OnMouseReleased(const views::MouseEvent& event) {
+void TabStrip::OnMouseReleased(const ui::MouseEvent& event) {
   EndDrag(false);
   UpdateLayoutTypeFromMouseEvent(this, event);
 }
 
 void TabStrip::OnMouseCaptureLost() {
   EndDrag(true);
 }
 
-void TabStrip::OnMouseMoved(const views::MouseEvent& event) {
+void TabStrip::OnMouseMoved(const ui::MouseEvent& event) {
   UpdateLayoutTypeFromMouseEvent(this, event);
 }
 
 ui::GestureStatus TabStrip::OnGestureEvent(
     const views::GestureEvent& event) {
   switch (event.type()) {
     case ui::ET_GESTURE_END:
       EndDrag(false);
       if (adjust_layout_ && ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
         SetLayoutType(TAB_STRIP_LAYOUT_STACKED, true);
@@ skipping 372 matching lines @@
     return;
 
   const std::vector<BaseTab*>& tabs = tabs_closing_map_[index];
   for (std::vector<BaseTab*>::const_reverse_iterator i(tabs.rbegin());
        i != tabs.rend(); ++i) {
     (*i)->Paint(canvas);
   }
 }
 
 void TabStrip::UpdateLayoutTypeFromMouseEvent(views::View* source,
-                                              const views::MouseEvent& event) {
+                                              const ui::MouseEvent& event) {
   if (!adjust_layout_ || ui::GetDisplayLayout() != ui::LAYOUT_TOUCH)
     return;
 
   // The following code attempts to switch to TAB_STRIP_LAYOUT_SHRINK when the
   // mouse is used, and TAB_STRIP_LAYOUT_STACKED when a touch device is
   // used. This is made problematic by windows generating mouse move events that
   // do not clearly indicate the move is the result of a touch device. This
   // assumes a real mouse is used if |kMouseMoveCountBeforeConsiderReal| mouse
   // move events are received within the time window |kMouseMoveTimeMS|.
   // At the time we get a mouse press we know whether its from a touch device
@@ skipping 549 matching lines @@
 
   int mini_tab_count = GetMiniTabCount();
   int normal_count = tab_count() - mini_tab_count;
   if (normal_count <= 1 || normal_count == mini_tab_count)
     return false;
   int x = GetStartXForNormalTabs();
   int available_width = width() - x - new_tab_button_width();
   return (Tab::GetTouchWidth() * normal_count +
           tab_h_offset() * (normal_count - 1)) > available_width;
 }