Change all ConvertPointTo* methods to use gfx::Point instead of CPoint....

chrome/views/chrome_menu.cc

 // Copyright (c) 2006-2008 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/views/chrome_menu.h"
 
 #include <windows.h>
 #include <uxtheme.h>
 #include <Vssym32.h>
 
@@ skipping 1717 matching lines @@
     return;
 
   if (possible_drag_) {
     if (ChromeViews::View::ExceededDragThreshold(event.x() - press_x_,
                                                  event.y() - press_y_)) {
       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.
-      CPoint press_loc(press_x_, press_y_);
+      gfx::Point press_loc(press_x_, press_y_);
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &press_loc);
       View::ConvertPointToView(NULL, item, &press_loc);
-      CPoint drag_loc(event.x(), event.y());
+      gfx::Point drag_loc(event.location());
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &drag_loc);
       View::ConvertPointToView(NULL, item, &drag_loc);
       in_drag_ = true;
       ChromeCanvas canvas(item->width(), item->height(), false);
       item->Paint(&canvas, true);
 
       scoped_refptr<OSExchangeData> data(new OSExchangeData);
       item->GetDelegate()->WriteDragData(item, data.get());
       drag_utils::SetDragImageOnDataObject(canvas, item->width(),
-                                           item->height(), press_loc.x,
-                                           press_loc.y, data);
+                                           item->height(), press_loc.x(),
+                                           press_loc.y(), data);
 
       scoped_refptr<BaseDragSource> drag_source(new BaseDragSource);
       int drag_ops = item->GetDelegate()->GetDragOperations(item);
       DWORD effects;
       StopScrolling();
       DoDragDrop(data, drag_source,
                  DragDropTypes::DragOperationToDropEffect(drag_ops),
                  &effects);
       if (GetActiveInstance() == this) {
         if (showing_ ) {
@@ skipping 27 matching lines @@
   MenuPart part =
       GetMenuPartByScreenCoordinate(source, event.x(), event.y());
   any_menu_contains_mouse_ = (part.type == MenuPart::MENU_ITEM);
   if (event.IsRightMouseButton() && (part.type == MenuPart::MENU_ITEM &&
                                      part.menu)) {
     // Set the selection immediately, making sure the submenu is only open
     // if it already was.
     bool open_submenu = (state_.item == pending_state_.item &&
                          state_.submenu_open);
     SetSelection(pending_state_.item, open_submenu, true);
-    CPoint loc(event.x(), event.y());
+    gfx::Point loc(event.location());
     View::ConvertPointToScreen(source->GetScrollViewContainer(), &loc);
 
     // If we open a context menu just return now
     if (part.menu->GetDelegate()->ShowContextMenu(
-        part.menu, part.menu->GetCommand(), loc.x, loc.y, true))
+        part.menu, part.menu->GetCommand(), loc.x(), loc.y(), true))
       return;
   }
 
   if (!part.is_scroll() && part.menu && !part.menu->HasSubmenu()) {
     if (part.menu->GetDelegate()->IsTriggerableEvent(event)) {
       Accept(part.menu, event.GetFlags());
       return;
     }
   } else if (part.type == MenuPart::MENU_ITEM) {
     // User either clicked on empty space, or a menu that has children.
@@ skipping 44 matching lines @@
 
 void MenuController::OnDragEntered(SubmenuView* source,
                                    const DropTargetEvent& event) {
   valid_drop_coordinates_ = false;
 }
 
 int MenuController::OnDragUpdated(SubmenuView* source,
                                   const DropTargetEvent& event) {
   StopCancelAllTimer();
 
-  CPoint screen_loc(event.x(), event.y());
+  gfx::Point screen_loc(event.location());
   View::ConvertPointToScreen(source, &screen_loc);
-  if (valid_drop_coordinates_ && screen_loc.x == drop_x_ &&
-      screen_loc.y == drop_y_) {
+  if (valid_drop_coordinates_ && screen_loc.x() == drop_x_ &&
+      screen_loc.y() == drop_y_) {
     return last_drop_operation_;
   }
-  drop_x_ = screen_loc.x;
-  drop_y_ = screen_loc.y;
+  drop_x_ = screen_loc.x();
+  drop_y_ = screen_loc.y();
   valid_drop_coordinates_ = true;
 
   MenuItemView* menu_item = GetMenuItemAt(source, event.x(), event.y());
   bool over_empty_menu = false;
   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 = DragDropTypes::DRAG_NONE;
   if (menu_item) {
-    CPoint menu_item_loc(event.x(), event.y());
+    gfx::Point menu_item_loc(event.location());
     View::ConvertPointToView(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 > MenuItemView::kDropBetweenPixels &&
-           menu_item_loc.y < (menu_item_height -
-                              MenuItemView::kDropBetweenPixels))) {
+          (menu_item_loc.y() > MenuItemView::kDropBetweenPixels &&
+           menu_item_loc.y() < (menu_item_height -
+                                MenuItemView::kDropBetweenPixels))) {
         drop_position = MenuDelegate::DROP_ON;
-      } else if (menu_item_loc.y < menu_item_height / 2) {
+      } else if (menu_item_loc.y() < menu_item_height / 2) {
         drop_position = MenuDelegate::DROP_BEFORE;
       } else {
         drop_position = MenuDelegate::DROP_AFTER;
       }
       query_menu_item = menu_item;
     } else {
       query_menu_item = menu_item->GetParentMenuItem();
       drop_position = MenuDelegate::DROP_ON;
     }
     drop_operation = menu_item->GetDelegate()->GetDropOperation(
@@ skipping 271 matching lines @@
   }
   return false;
 }
 
 MenuController::MenuPart MenuController::GetMenuPartByScreenCoordinate(
     SubmenuView* source,
     int source_x,
     int source_y) {
   MenuPart part;
 
-  CPoint screen_loc(source_x, source_y);
+  gfx::Point screen_loc(source_x, source_y);
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
 
   MenuItemView* item = state_.item;
   while (item) {
     if (item->HasSubmenu() && item->GetSubmenu()->IsShowing() &&
         GetMenuPartByScreenCoordinateImpl(item->GetSubmenu(), screen_loc,
                                           &part)) {
       return part;
     }
     item = item->GetParentMenuItem();
   }
 
   return part;
 }
 
 bool MenuController::GetMenuPartByScreenCoordinateImpl(
     SubmenuView* menu,
-    const CPoint& screen_loc,
+    const gfx::Point& screen_loc,
     MenuPart* part) {
   // Is the mouse over the scroll buttons?
-  CPoint scroll_view_loc = screen_loc;
+  gfx::Point scroll_view_loc = screen_loc;
   View* scroll_view_container = menu->GetScrollViewContainer();
   View::ConvertPointToView(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()) {
+  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,
+  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)) {
-    CPoint menu_loc = screen_loc;
+    gfx::Point menu_loc = screen_loc;
     View::ConvertPointToView(NULL, menu, &menu_loc);
-    part->menu = GetMenuItemAt(menu, menu_loc.x, menu_loc.y);
+    part->menu = GetMenuItemAt(menu, menu_loc.x(), menu_loc.y());
     part->type = MenuPart::MENU_ITEM;
     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 CPoint& screen_loc) {
-  CPoint view_loc = screen_loc;
+                                                const gfx::Point& screen_loc) {
+  gfx::Point view_loc = screen_loc;
   View::ConvertPointToView(NULL, submenu, &view_loc);
   gfx::Rect vis_rect = submenu->GetVisibleBounds();
-  return vis_rect.Contains(view_loc.x, view_loc.y);
+  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;
   BuildPathsAndCalculateDiff(state_.item, pending_state_.item, &current_path,
                              &new_path, &paths_differ_at);
@@ skipping 187 matching lines @@
             static_cast<LONG>(state_.monitor_bounds.bottom() - y));
       } else {
         pref.cy = std::min(pref.cy, static_cast<LONG>(
             state_.initial_bounds.y() - state_.monitor_bounds.y()));
         y = state_.initial_bounds.y() - pref.cy;
       }
     }
   } else {
     // Not the first menu; position it relative to the bounds of the menu
     // item.
-    CPoint item_loc(0, 0);
+    gfx::Point item_loc;
     View::ConvertPointToScreen(item, &item_loc);
 
     // We must make sure we take into account the UI layout. If the layout is
     // RTL, then a 'leading' menu is positioned to the left of the parent menu
     // item and not to the right.
     bool layout_is_rtl = item->UILayoutIsRightToLeft();
     bool create_on_the_right = (prefer_leading && !layout_is_rtl) ||
                                (!prefer_leading && layout_is_rtl);
 
     if (create_on_the_right) {
-      x = item_loc.x + item->width() - kSubmenuHorizontalInset;
+      x = item_loc.x() + item->width() - kSubmenuHorizontalInset;
       if (state_.monitor_bounds.width() != 0 &&
           x + pref.cx > state_.monitor_bounds.right()) {
         if (layout_is_rtl)
           *is_leading = true;
         else
           *is_leading = false;
-        x = item_loc.x - pref.cx + kSubmenuHorizontalInset;
+        x = item_loc.x() - pref.cx + kSubmenuHorizontalInset;
       }
     } else {
-      x = item_loc.x - pref.cx + kSubmenuHorizontalInset;
+      x = item_loc.x() - pref.cx + kSubmenuHorizontalInset;
       if (state_.monitor_bounds.width() != 0 && x < state_.monitor_bounds.x()) {
         if (layout_is_rtl)
           *is_leading = false;
         else
           *is_leading = true;
-        x = item_loc.x + item->width() - kSubmenuHorizontalInset;
+        x = item_loc.x() + item->width() - kSubmenuHorizontalInset;
       }
     }
-    y = item_loc.y - kSubmenuBorderSize;
+    y = item_loc.y() - kSubmenuBorderSize;
     if (state_.monitor_bounds.width() != 0) {
       pref.cy = std::min(pref.cy,
                          static_cast<LONG>(state_.monitor_bounds.height()));
       if (y + pref.cy > state_.monitor_bounds.bottom())
         y = state_.monitor_bounds.bottom() - pref.cy;
       if (y < state_.monitor_bounds.y())
         y = state_.monitor_bounds.y();
     }
   }
 
@@ skipping 130 matching lines @@
       SetSelection(submenu->GetMenuItemAt(first_match), false, false);
     } else {
       SetSelection(submenu->GetMenuItemAt(next_match), false, false);
     }
   }
   return false;
 }
 
 void MenuController::RepostEvent(SubmenuView* source,
                                  const MouseEvent& event) {
-  CPoint screen_loc(event.x(), event.y());
+  gfx::Point screen_loc(event.location());
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
-  HWND window = WindowFromPoint(screen_loc);
+  HWND window = WindowFromPoint(screen_loc.ToPOINT());
   if (window) {
 #ifdef DEBUG_MENU
     DLOG(INFO) << "RepostEvent on press";
 #endif
 
     // Release the capture.
     SubmenuView* submenu = state_.item->GetRootMenuItem()->GetSubmenu();
     submenu->ReleaseCapture();
 
     if (submenu->host() && submenu->host()->GetHWND() &&
         GetWindowThreadProcessId(submenu->host()->GetHWND(), NULL) !=
         GetWindowThreadProcessId(window, NULL)) {
       // Even though we have mouse capture, windows generates a mouse event
       // if the other window is in a separate thread. Don't generate an event in
       // this case else the target window can get double events leading to bad
       // behavior.
       return;
     }
 
     // Convert the coordinates to the target window.
     RECT window_bounds;
     GetWindowRect(window, &window_bounds);
-    int window_x = screen_loc.x - window_bounds.left;
-    int window_y = screen_loc.y - window_bounds.top;
+    int window_x = screen_loc.x() - window_bounds.left;
+    int window_y = screen_loc.y() - window_bounds.top;
 
     // Determine whether the click was in the client area or not.
     // NOTE: WM_NCHITTEST coordinates are relative to the screen.
     LRESULT nc_hit_result = SendMessage(window, WM_NCHITTEST, 0,
-                                        MAKELPARAM(screen_loc.x, screen_loc.y));
+                                        MAKELPARAM(screen_loc.x(),
+                                                   screen_loc.y()));
     const bool in_client_area = (nc_hit_result == HTCLIENT);
 
     // TODO(sky): this isn't right. The event to generate should correspond
     // with the event we just got. MouseEvent only tells us what is down,
     // which may differ. Need to add ability to get changed button from
     // MouseEvent.
     int event_type;
     if (event.IsLeftMouseButton())
       event_type = in_client_area ? WM_LBUTTONDOWN : WM_NCLBUTTONDOWN;
     else if (event.IsMiddleMouseButton())
@@ skipping 41 matching lines @@
     scroll_task_.reset(new MenuScrollTask());
   scroll_task_->Update(part);
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 }  // namespace ChromeViews