Replace views::LocatedEvent with ui::LocatedEvent

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 247 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ResetDraggingStateDelegate);
 };
 
 // If |dest| contains the point |point_in_source| the event handler from |dest|
 // is returned. Otherwise NULL is returned.
 views::View* ConvertPointToViewAndGetEventHandler(
     views::View* source,
     views::View* dest,
     const gfx::Point& point_in_source) {
   gfx::Point dest_point(point_in_source);
-  views::View::ConvertPointToView(source, dest, &dest_point);
+  views::View::ConvertPointToTarget(source, dest, &dest_point);
   return dest->HitTestPoint(dest_point) ?
       dest->GetEventHandlerForPoint(dest_point) : NULL;
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // NewTabButton
 //
 //  A subclass of button that hit-tests to the shape of the new tab button and
@@ skipping 576 matching lines @@
 
   // If there is no control at this location, claim the hit was in the title
   // bar to get a move action.
   if (v == this)
     return true;
 
   // Check to see if the point is within the non-button parts of the new tab
   // button. The button has a non-rectangular shape, so if it's not in the
   // visual portions of the button we treat it as a click to the caption.
   gfx::Point point_in_newtab_coords(point);
-  View::ConvertPointToView(this, newtab_button_, &point_in_newtab_coords);
+  View::ConvertPointToTarget(this, newtab_button_, &point_in_newtab_coords);
   if (newtab_button_->GetLocalBounds().Contains(point_in_newtab_coords) &&
       !newtab_button_->HitTestPoint(point_in_newtab_coords)) {
     return true;
   }
 
   // All other regions, including the new Tab button, should be considered part
   // of the containing Window's client area so that regular events can be
   // processed for them.
   return false;
 }
@@ skipping 86 matching lines @@
   if (tab->closing())
     return false;
 
   int model_index = GetModelIndexOfBaseTab(tab);
   return IsValidModelIndex(model_index) &&
       controller_->IsTabPinned(model_index);
 }
 
 void TabStrip::MaybeStartDrag(
     BaseTab* tab,
-    const views::LocatedEvent& event,
+    const ui::LocatedEvent& event,
     const TabStripSelectionModel& original_selection) {
   // Don't accidentally start any drag operations during animations if the
   // mouse is down... during an animation tabs are being resized automatically,
   // so the View system can misinterpret this easily if the mouse is down that
   // the user is dragging.
   if (IsAnimating() || tab->closing() ||
       controller_->HasAvailableDragActions() == 0) {
     return;
   }
   int model_index = GetModelIndexOfBaseTab(tab);
@@ skipping 73 matching lines @@
   if (!drag_controller_.get())
     return false;
   bool started_drag = drag_controller_->started_drag();
   drag_controller_->EndDrag(canceled);
   return started_drag;
 }
 
 BaseTab* TabStrip::GetTabAt(BaseTab* tab,
                             const gfx::Point& tab_in_tab_coordinates) {
   gfx::Point local_point = tab_in_tab_coordinates;
-  ConvertPointToView(tab, this, &local_point);
+  ConvertPointToTarget(tab, this, &local_point);
 
   views::View* view = GetEventHandlerForPoint(local_point);
   if (!view)
     return NULL;  // No tab contains the point.
 
   // Walk up the view hierarchy until we find a tab, or the TabStrip.
   while (view && view != this && view->id() != VIEW_ID_TAB)
     view = view->parent();
 
   return view && view->id() == VIEW_ID_TAB ? static_cast<BaseTab*>(view) : NULL;
@@ skipping 747 matching lines @@
     case ui::ET_MOUSE_MOVED: {
 #if !defined(OS_WIN)
       SetLayoutType(TAB_STRIP_LAYOUT_SHRINK, true);
       break;
 #endif
       // Switch to shrink if the mouse enters and it's not a synthesized event.
       // We ignore synthesized events as EF_FROM_TOUCH is not necessarily set
       // correctly (highlighting the close button doesn't set the flags
       // correctly).
       gfx::Point location(event.location());
-      ConvertPointToView(source, this, &location);
+      ConvertPointToTarget(source, this, &location);
       if (location == last_mouse_move_location_)
         return;  // Ignore spurious moves.
       last_mouse_move_location_ = location;
       if ((event.flags() & ui::EF_FROM_TOUCH) == 0 &&
           (event.flags() & ui::EF_IS_SYNTHESIZED) == 0) {
         if ((base::TimeTicks::Now() - last_mouse_move_time_).InMilliseconds() <
             kMouseMoveTimeMS) {
           if (mouse_move_count_++ == kMouseMoveCountBeforeConsiderReal) {
             SetLayoutType(TAB_STRIP_LAYOUT_SHRINK, true);
             // Don't notify the controller here. We only want to commit the
             // change to other tabstrips on a release.
           }
         } else {
           mouse_move_count_ = 1;
           last_mouse_move_time_ = base::TimeTicks::Now();
         }
       } else {
         last_mouse_move_time_ = base::TimeTicks();
       }
       break;
     }
 
     case ui::ET_MOUSE_RELEASED: {
       gfx::Point location(event.location());
-      ConvertPointToView(source, this, &location);
+      ConvertPointToTarget(source, this, &location);
       last_mouse_move_location_ = location;
 
       mouse_move_count_ = 0;
       last_mouse_move_time_ = base::TimeTicks();
 
       if ((event.flags() & ui::EF_FROM_TOUCH) == ui::EF_FROM_TOUCH)
         SetLayoutType(TAB_STRIP_LAYOUT_STACKED, true);
       else if (reset_to_shrink_on_release_)
         SetLayoutType(TAB_STRIP_LAYOUT_SHRINK, true);
       controller_->LayoutTypeMaybeChanged();
@@ skipping 420 matching lines @@
   // ownership of RemoveTabDelegate.
   bounds_animator_.SetAnimationDelegate(
       tab_closing,
       new RemoveTabDelegate(this, tab_closing),
       true);
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
-  View::ConvertPointToView(this, tab, &point_in_tab_coords);
+  View::ConvertPointToTarget(this, tab, &point_in_tab_coords);
   return tab->HitTestPoint(point_in_tab_coords);
 }
 
 int TabStrip::GetStartXForNormalTabs() const {
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == 0)
     return 0;
   return mini_tab_count * (Tab::GetMiniWidth() + tab_h_offset()) +
       kMiniToNonMiniGap;
 }
@@ skipping 49 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;
 }