Replace views::LocatedEvent with ui::LocatedEvent

ui/views/controls/menu/menu_controller.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/controls/menu/menu_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/run_loop.h"
 #include "base/time.h"
@@ skipping 595 matching lines @@
   if (!menu_item) {
     // See if we're over an empty menu.
     menu_item = GetEmptyMenuItemAt(source, event.x(), event.y());
     if (menu_item)
       over_empty_menu = true;
   }
   MenuDelegate::DropPosition drop_position = MenuDelegate::DROP_NONE;
   int drop_operation = ui::DragDropTypes::DRAG_NONE;
   if (menu_item) {
     gfx::Point menu_item_loc(event.location());
-    View::ConvertPointToView(source, menu_item, &menu_item_loc);
+    View::ConvertPointToTarget(source, menu_item, &menu_item_loc);
     MenuItemView* query_menu_item;
     if (!over_empty_menu) {
       int menu_item_height = menu_item->height();
       if (menu_item->HasSubmenu() &&
           (menu_item_loc.y() > kDropBetweenPixels &&
            menu_item_loc.y() < (menu_item_height - kDropBetweenPixels))) {
         drop_position = MenuDelegate::DROP_ON;
       } else {
         drop_position = (menu_item_loc.y() < menu_item_height / 2) ?
             MenuDelegate::DROP_BEFORE : MenuDelegate::DROP_AFTER;
@@ skipping 155 matching lines @@
   // Notify an accessibility focus event on all menu items except for the root.
   if (menu_item &&
       (MenuDepth(menu_item) != 1 ||
        menu_item->GetType() != MenuItemView::SUBMENU)) {
     menu_item->GetWidget()->NotifyAccessibilityEvent(
         menu_item, ui::AccessibilityTypes::EVENT_FOCUS, true);
   }
 }
 
 void MenuController::SetSelectionOnPointerDown(SubmenuView* source,
-                                               const LocatedEvent& event) {
+                                               const ui::LocatedEvent& event) {
   if (!blocking_run_)
     return;
   drop_first_release_event_ = false;
 
   DCHECK(!active_mouse_view_);
 
   MenuPart part = GetMenuPart(source, event.location());
   if (part.is_scroll())
     return;  // Ignore presses on scroll buttons.
 
@@ skipping 51 matching lines @@
 
 void MenuController::StartDrag(SubmenuView* source,
                                const gfx::Point& location) {
   MenuItemView* item = state_.item;
   DCHECK(item);
   // Points are in the coordinates of the submenu, need to map to that of
   // the selected item. Additionally source may not be the parent of
   // the selected item, so need to map to screen first then to item.
   gfx::Point press_loc(location);
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &press_loc);
-  View::ConvertPointToView(NULL, item, &press_loc);
+  View::ConvertPointToTarget(NULL, item, &press_loc);
   gfx::Point widget_loc(press_loc);
   View::ConvertPointToWidget(item, &widget_loc);
   scoped_ptr<gfx::Canvas> canvas(views::GetCanvasForDragImage(
       source->GetWidget(), gfx::Size(item->width(), item->height())));
   item->PaintButton(canvas.get(), MenuItemView::PB_FOR_DRAG);
 
   OSExchangeData data;
   item->GetDelegate()->WriteDragData(item, &data);
   drag_utils::SetDragImageOnDataObject(*canvas, item->size(), press_loc,
                                        &data);
@@ skipping 328 matching lines @@
   alt_menu->PrepareForRun(
       has_mnemonics,
       source->GetMenuItem()->GetRootMenuItem()->show_mnemonics_);
   alt_menu->controller_ = this;
   SetSelection(alt_menu, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
   return true;
 }
 
 bool MenuController::ShowContextMenu(MenuItemView* menu_item,
                                      SubmenuView* source,
-                                     const LocatedEvent& event) {
+                                     const ui::LocatedEvent& event) {
   // Set the selection immediately, making sure the submenu is only open
   // if it already was.
   int selection_types = SELECTION_UPDATE_IMMEDIATELY;
   if (state_.item == pending_state_.item && state_.submenu_open)
     selection_types |= SELECTION_OPEN_SUBMENU;
   SetSelection(pending_state_.item, selection_types);
   gfx::Point loc(event.location());
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &loc);
 
   if (menu_item->GetDelegate()->ShowContextMenu(
@@ skipping 83 matching lines @@
   return part;
 }
 
 bool MenuController::GetMenuPartByScreenCoordinateImpl(
     SubmenuView* menu,
     const gfx::Point& screen_loc,
     MenuPart* part) {
   // Is the mouse over the scroll buttons?
   gfx::Point scroll_view_loc = screen_loc;
   View* scroll_view_container = menu->GetScrollViewContainer();
-  View::ConvertPointToView(NULL, scroll_view_container, &scroll_view_loc);
+  View::ConvertPointToTarget(NULL, scroll_view_container, &scroll_view_loc);
   if (scroll_view_loc.x() < 0 ||
       scroll_view_loc.x() >= scroll_view_container->width() ||
       scroll_view_loc.y() < 0 ||
       scroll_view_loc.y() >= scroll_view_container->height()) {
     // Point isn't contained in menu.
     return false;
   }
   if (IsScrollButtonAt(menu, scroll_view_loc.x(), scroll_view_loc.y(),
                        &(part->type))) {
     part->submenu = menu;
     return true;
   }
 
   // Not over the scroll button. Check the actual menu.
   if (DoesSubmenuContainLocation(menu, screen_loc)) {
     gfx::Point menu_loc = screen_loc;
-    View::ConvertPointToView(NULL, menu, &menu_loc);
+    View::ConvertPointToTarget(NULL, menu, &menu_loc);
     part->menu = GetMenuItemAt(menu, menu_loc.x(), menu_loc.y());
     part->type = MenuPart::MENU_ITEM;
     part->submenu = menu;
     if (!part->menu)
       part->parent = menu->GetMenuItem();
     return true;
   }
 
   // While the mouse isn't over a menu item or the scroll buttons of menu, it
   // is contained by menu and so we return true. If we didn't return true other
   // menus would be searched, even though they are likely obscured by us.
   return true;
 }
 
 bool MenuController::DoesSubmenuContainLocation(SubmenuView* submenu,
                                                 const gfx::Point& screen_loc) {
   gfx::Point view_loc = screen_loc;
-  View::ConvertPointToView(NULL, submenu, &view_loc);
+  View::ConvertPointToTarget(NULL, submenu, &view_loc);
   gfx::Rect vis_rect = submenu->GetVisibleBounds();
   return vis_rect.Contains(view_loc.x(), view_loc.y());
 }
 
 void MenuController::CommitPendingSelection() {
   StopShowTimer();
 
   size_t paths_differ_at = 0;
   std::vector<MenuItemView*> current_path;
   std::vector<MenuItemView*> new_path;
@@ skipping 541 matching lines @@
   // If no mnemonics found, look at first character of titles.
   details = FindChildForMnemonic(item, key, &TitleMatchesMnemonic);
   if (details.first_match != -1)
     return AcceptOrSelect(item, details);
 
   return false;
 }
 
 #if defined(OS_WIN) && !defined(USE_AURA)
 void MenuController::RepostEvent(SubmenuView* source,
-                                 const LocatedEvent& event) {
+                                 const ui::LocatedEvent& event) {
   if (!state_.item) {
     // We some times get an event after closing all the menus. Ignore it.
     // Make sure the menu is in fact not visible. If the menu is visible, then
     // we're in a bad state where we think the menu isn't visibile but it is.
     DCHECK(!source->GetWidget()->IsVisible());
     return;
   }
 
   gfx::Point screen_loc(event.location());
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
@@ skipping 90 matching lines @@
                                            View* target_menu) {
   View* target = NULL;
   gfx::Point target_menu_loc(event.location());
   if (target_menu && target_menu->has_children()) {
     // Locate the deepest child view to send events to.  This code assumes we
     // don't have to walk up the tree to find a view interested in events. This
     // is currently true for the cases we are embedding views, but if we embed
     // more complex hierarchies it'll need to change.
     View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                                &target_menu_loc);
-    View::ConvertPointToView(NULL, target_menu, &target_menu_loc);
+    View::ConvertPointToTarget(NULL, target_menu, &target_menu_loc);
     target = target_menu->GetEventHandlerForPoint(target_menu_loc);
     if (target == target_menu || !target->enabled())
       target = NULL;
   }
   if (target != active_mouse_view_) {
     SendMouseCaptureLostToActiveView();
     active_mouse_view_ = target;
     if (active_mouse_view_) {
       gfx::Point target_point(target_menu_loc);
-      View::ConvertPointToView(target_menu, active_mouse_view_, &target_point);
+      View::ConvertPointToTarget(
+          target_menu, active_mouse_view_, &target_point);
       MouseEvent mouse_entered_event(ui::ET_MOUSE_ENTERED,
                                      target_point.x(), target_point.y(), 0);
       active_mouse_view_->OnMouseEntered(mouse_entered_event);
 
       MouseEvent mouse_pressed_event(ui::ET_MOUSE_PRESSED,
                                      target_point.x(), target_point.y(),
                                      event.flags());
       active_mouse_view_->OnMousePressed(mouse_pressed_event);
     }
   }
 
   if (active_mouse_view_) {
     gfx::Point target_point(target_menu_loc);
-    View::ConvertPointToView(target_menu, active_mouse_view_, &target_point);
+    View::ConvertPointToTarget(target_menu, active_mouse_view_, &target_point);
     MouseEvent mouse_dragged_event(ui::ET_MOUSE_DRAGGED,
                                    target_point.x(), target_point.y(),
                                    event.flags());
     active_mouse_view_->OnMouseDragged(mouse_dragged_event);
   }
 }
 
 void MenuController::SendMouseReleaseToActiveView(SubmenuView* event_source,
                                                   const MouseEvent& event) {
   if (!active_mouse_view_)
     return;
 
   gfx::Point target_loc(event.location());
   View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                              &target_loc);
-  View::ConvertPointToView(NULL, active_mouse_view_, &target_loc);
+  View::ConvertPointToTarget(NULL, active_mouse_view_, &target_loc);
   MouseEvent release_event(ui::ET_MOUSE_RELEASED, target_loc.x(),
                            target_loc.y(), event.flags());
   // Reset the active_mouse_view_ before sending mouse released. That way if it
   // calls back to us, we aren't in a weird state.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
   active_view->OnMouseReleased(release_event);
 }
 
 void MenuController::SendMouseCaptureLostToActiveView() {
@@ skipping 64 matching lines @@
 
 #if defined(USE_AURA)
 void MenuController::OnWindowActivated(aura::Window* active,
                                        aura::Window* old_active) {
   if (!drag_in_progress_)
     Cancel(EXIT_ALL);
 }
 #endif
 
 }  // namespace views