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

chrome/views/tooltip_manager.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 <limits>
 
 #include "chrome/common/gfx/chrome_font.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/common/l10n_util.h"
@@ skipping 145 matching lines @@
             reinterpret_cast<NMTTDISPINFOW*>(l_param);
         // Initialize the string, if we have a valid tooltip the string will
         // get reset below.
         tooltip_info->szText[0] = TEXT('\0');
         tooltip_text_.clear();
         tooltip_info->lpszText = NULL;
         clipped_text_.clear();
         if (last_tooltip_view_ != NULL) {
           tooltip_text_.clear();
           // Mouse is over a View, ask the View for it's tooltip.
-          CPoint view_loc(last_mouse_x_, last_mouse_y_);
+          gfx::Point view_loc(last_mouse_x_, last_mouse_y_);
           View::ConvertPointToView(view_container_->GetRootView(),
                                    last_tooltip_view_, &view_loc);
-          if (last_tooltip_view_->GetTooltipText(view_loc.x, view_loc.y,
+          if (last_tooltip_view_->GetTooltipText(view_loc.x(), view_loc.y(),
                                                  &tooltip_text_) &&
               !tooltip_text_.empty()) {
             // View has a valid tip, copy it into TOOLTIPINFO.
             clipped_text_ = tooltip_text_;
             TrimTooltipToFit(&clipped_text_, &tooltip_width_, &line_count_,
                              last_mouse_x_, last_mouse_y_, tooltip_hwnd_);
             tooltip_info->lpszText = const_cast<WCHAR*>(clipped_text_.c_str());
           } else {
             tooltip_text_.clear();
           }
         }
         *handled = true;
         return 0;
       }
       case TTN_POP:
         tooltip_showing_ = false;
         *handled = true;
         return 0;
       case TTN_SHOW: {
         *handled = true;
         tooltip_showing_ = true;
         // The tooltip is about to show, allow the view to position it
         CPoint text_origin;
         if (tooltip_height_ == 0)
           tooltip_height_ = CalcTooltipHeight();
-        CPoint view_loc(last_mouse_x_, last_mouse_y_);
+        gfx::Point view_loc(last_mouse_x_, last_mouse_y_);
         View::ConvertPointToView(view_container_->GetRootView(),
                                  last_tooltip_view_, &view_loc);
         if (last_tooltip_view_->GetTooltipTextOrigin(
-              view_loc.x, view_loc.y, &text_origin) &&
+              view_loc.x(), view_loc.y(), &text_origin) &&
             SetTooltipPosition(text_origin.x, text_origin.y)) {
           // Return true, otherwise the rectangle we specified is ignored.
           return TRUE;
         }
         return 0;
       }
       default:
         // Fall through.
         break;
     }
   }
   return 0;
 }
 
 bool TooltipManager::SetTooltipPosition(int text_x, int text_y) {
   // NOTE: this really only tests that the y location fits on screen, but that
   // is good enough for our usage.
 
   // Calculate the bounds the tooltip will get.
-  CPoint view_loc(0, 0);
+  gfx::Point view_loc;
   View::ConvertPointToScreen(last_tooltip_view_, &view_loc);
-  RECT bounds = { view_loc.x + text_x,
-                  view_loc.y + text_y,
-                  view_loc.x + text_x + tooltip_width_,
-                  view_loc.y + line_count_ * GetTooltipHeight() };
+  RECT bounds = { view_loc.x() + text_x,
+                  view_loc.y() + text_y,
+                  view_loc.x() + text_x + tooltip_width_,
+                  view_loc.y() + line_count_ * GetTooltipHeight() };
   SendMessage(tooltip_hwnd_, TTM_ADJUSTRECT, TRUE, (LPARAM)&bounds);
 
   // Make sure the rectangle completely fits on the current monitor. If it
   // doesn't, return false so that windows positions the tooltip at the
   // default location.
   gfx::Rect monitor_bounds =
       win_util::GetMonitorBoundsForRect(gfx::Rect(bounds.left,bounds.right,
                                                   0, 0));
   if (!monitor_bounds.Contains(gfx::Rect(bounds))) {
     return false;
@@ skipping 40 matching lines @@
   *max_width = 0;
   *line_count = 0;
 
   // Clamp the tooltip length to kMaxTooltipLength so that we don't
   // accidentally DOS the user with a mega tooltip (since Windows doesn't seem
   // to do this itself).
   if (text->length() > kMaxTooltipLength)
     *text = text->substr(0, kMaxTooltipLength);
 
   // Determine the available width for the tooltip.
-  CPoint screen_loc(position_x, position_y);
+  gfx::Point screen_loc(position_x, position_y);
   View::ConvertPointToScreen(view_container_->GetRootView(), &screen_loc);
   gfx::Rect monitor_bounds =
-      win_util::GetMonitorBoundsForRect(gfx::Rect(screen_loc.x, screen_loc.y,
+      win_util::GetMonitorBoundsForRect(gfx::Rect(screen_loc.x(), screen_loc.y(),
                                                   0, 0));
   RECT tooltip_margin;
   SendMessage(window, TTM_GETMARGIN, 0, (LPARAM)&tooltip_margin);
   const int available_width = monitor_bounds.width() - tooltip_margin.left -
       tooltip_margin.right;
   if (available_width <= 0)
     return;
 
   // Split the string.
   std::vector<std::wstring> lines;
@@ skipping 22 matching lines @@
   RootView* root_view = view_container_->GetRootView();
   View* view = root_view->GetViewForPoint(CPoint(x, y));
   if (view != last_tooltip_view_) {
     // NOTE: This *must* be sent regardless of the visibility of the tooltip.
     // It triggers Windows to ask for the tooltip again.
     SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
     last_tooltip_view_ = view;
   } else if (last_tooltip_view_ != NULL) {
     // Tooltip is showing, and mouse is over the same view. See if the tooltip
     // text has changed.
-    CPoint view_point(x, y);
+    gfx::Point view_point(x, y);
     View::ConvertPointToView(root_view, last_tooltip_view_, &view_point);
     std::wstring new_tooltip_text;
-    if (last_tooltip_view_->GetTooltipText(view_point.x, view_point.y,
+    if (last_tooltip_view_->GetTooltipText(view_point.x(), view_point.y(),
                                            &new_tooltip_text) &&
         new_tooltip_text != tooltip_text_) {
       // The text has changed, hide the popup.
       SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
       if (!new_tooltip_text.empty() && tooltip_showing_) {
         // New text is valid, show the popup.
         SendMessage(tooltip_hwnd_, TTM_POPUP, 0, 0);
       }
     }
   }
@@ skipping 29 matching lines @@
 void TooltipManager::ShowKeyboardTooltip(View* focused_view) {
   if (tooltip_showing_) {
     SendMessage(tooltip_hwnd_, TTM_POP, 0, 0);
     tooltip_text_.clear();
   }
   HideKeyboardTooltip();
   std::wstring tooltip_text;
   if (!focused_view->GetTooltipText(0, 0, &tooltip_text))
     return;
   gfx::Rect focused_bounds = focused_view->bounds();
-  CPoint screen_point;
+  gfx::Point screen_point;
   focused_view->ConvertPointToScreen(focused_view, &screen_point);
-  CPoint relative_point_coordinates;
+  gfx::Point relative_point_coordinates;
   focused_view->ConvertPointToViewContainer(focused_view,
                                             &relative_point_coordinates);
   keyboard_tooltip_hwnd_ = CreateWindowEx(
       WS_EX_TRANSPARENT | l10n_util::GetExtendedTooltipStyles(),
       TOOLTIPS_CLASS, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
   SendMessage(keyboard_tooltip_hwnd_, TTM_SETMAXTIPWIDTH, 0,
               std::numeric_limits<short>::max());
   int tooltip_width;
   int line_count;
   TrimTooltipToFit(&tooltip_text, &tooltip_width, &line_count,
-                   relative_point_coordinates.x, relative_point_coordinates.y,
-                   keyboard_tooltip_hwnd_);
+                   relative_point_coordinates.x(),
+                   relative_point_coordinates.y(), keyboard_tooltip_hwnd_);
   TOOLINFO keyboard_toolinfo;
   memset(&keyboard_toolinfo, 0, sizeof(keyboard_toolinfo));
   keyboard_toolinfo.cbSize = sizeof(keyboard_toolinfo);
   keyboard_toolinfo.hwnd = parent_;
   keyboard_toolinfo.uFlags = TTF_TRACK | TTF_TRANSPARENT | TTF_IDISHWND ;
   keyboard_toolinfo.lpszText = const_cast<WCHAR*>(tooltip_text.c_str());
   SendMessage(keyboard_tooltip_hwnd_, TTM_ADDTOOL, 0,
               reinterpret_cast<LPARAM>(&keyboard_toolinfo));
   SendMessage(keyboard_tooltip_hwnd_, TTM_TRACKACTIVATE,  TRUE,
               reinterpret_cast<LPARAM>(&keyboard_toolinfo));
   if (!tooltip_height_)
     tooltip_height_ = CalcTooltipHeight();
-  RECT rect_bounds = {screen_point.x, screen_point.y + focused_bounds.height(),
-                      screen_point.x + tooltip_width,
-                      screen_point.y + focused_bounds.height() +
+  RECT rect_bounds = {screen_point.x(),
+                      screen_point.y() + focused_bounds.height(),
+                      screen_point.x() + tooltip_width,
+                      screen_point.y() + focused_bounds.height() +
                       line_count * tooltip_height_ };
   gfx::Rect monitor_bounds =
       win_util::GetMonitorBoundsForRect(gfx::Rect(rect_bounds));
   rect_bounds = gfx::Rect(rect_bounds).AdjustToFit(monitor_bounds).ToRECT();
   ::SetWindowPos(keyboard_tooltip_hwnd_, NULL, rect_bounds.left,
                  rect_bounds.top, 0, 0,
                  SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       keyboard_tooltip_factory_.NewRunnableMethod(
       &TooltipManager::DestroyKeyboardTooltipWindow, keyboard_tooltip_hwnd_),
       kDefaultTimeout);
 }
 
 void TooltipManager::HideKeyboardTooltip() {
   if (keyboard_tooltip_hwnd_ != NULL) {
     SendMessage(keyboard_tooltip_hwnd_, WM_CLOSE, 0, 0);
     keyboard_tooltip_hwnd_ = NULL;
   }
 }
 
 void TooltipManager::DestroyKeyboardTooltipWindow(HWND window_to_destroy) {
   if (keyboard_tooltip_hwnd_ == window_to_destroy)
     HideKeyboardTooltip();
 }
 
 } // namespace ChromeViews