Adding the page and DPI scale adjustment for Autofill Popups.

chrome/browser/ui/autofill/autofill_popup_controller_impl.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/autofill/autofill_popup_controller_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/ui/autofill/autofill_popup_delegate.h"
 #include "chrome/browser/ui/autofill/autofill_popup_view.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "grit/webkit_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAutofillClient.h"
 #include "ui/base/events/event.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/display.h"
+#include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/vector2d.h"
 
 using WebKit::WebAutofillClient;
 
 namespace {
 
 // Used to indicate that no line is currently selected by the user.
 const int kNoSelection = -1;
 
@@ skipping 37 matching lines @@
   { "visaCC", IDR_AUTOFILL_CC_VISA },
 };
 
 }  // end namespace
 
 // static
 AutofillPopupControllerImpl* AutofillPopupControllerImpl::GetOrCreate(
     AutofillPopupControllerImpl* previous,
     AutofillPopupDelegate* delegate,
     gfx::NativeView container_view,
-    const gfx::Rect& element_bounds) {
+    const gfx::RectF& element_bounds) {
   DCHECK(!previous || previous->delegate_ == delegate);
 
   if (previous &&
       previous->container_view() == container_view &&
       previous->element_bounds() == element_bounds) {
     return previous;
   }
 
   if (previous)
     previous->Hide();
 
   return new AutofillPopupControllerImpl(
       delegate, container_view, element_bounds);
 }
 
 AutofillPopupControllerImpl::AutofillPopupControllerImpl(
     AutofillPopupDelegate* delegate,
     gfx::NativeView container_view,
-    const gfx::Rect& element_bounds)
+    const gfx::RectF& element_bounds)
     : view_(NULL),
       delegate_(delegate),
       container_view_(container_view),
       element_bounds_(element_bounds),
       selected_line_(kNoSelection),
       delete_icon_hovered_(false),
       is_hiding_(false),
       inform_delegate_of_destruction_(true) {
 #if !defined(OS_ANDROID)
   subtext_font_ = name_font_.DeriveFont(kLabelFontSizeDelta);
@@ skipping 173 matching lines @@
 }
 
 const gfx::Rect& AutofillPopupControllerImpl::popup_bounds() const {
   return popup_bounds_;
 }
 
 gfx::NativeView AutofillPopupControllerImpl::container_view() const {
   return container_view_;
 }
 
-const gfx::Rect& AutofillPopupControllerImpl::element_bounds() const {
+const gfx::RectF& AutofillPopupControllerImpl::element_bounds() const {
   return element_bounds_;
 }
 
 const std::vector<string16>& AutofillPopupControllerImpl::names() const {
   return names_;
 }
 
 const std::vector<string16>& AutofillPopupControllerImpl::subtexts() const {
   return subtexts_;
 }
@@ skipping 197 matching lines @@
 }
 
 #if !defined(OS_ANDROID)
 int AutofillPopupControllerImpl::GetDesiredPopupWidth() const {
   if (!name_font_.platform_font() || !subtext_font_.platform_font()) {
     // We can't calculate the size of the popup if the fonts
     // aren't present.
     return 0;
   }
 
-  int popup_width = element_bounds().width();
+  int popup_width = RoundedElementBounds().width();
   DCHECK_EQ(names().size(), subtexts().size());
   for (size_t i = 0; i < names().size(); ++i) {
     int row_size = name_font_.GetStringWidth(names()[i]) +
         subtext_font_.GetStringWidth(subtexts()[i]) +
         RowWidthWithoutText(i);
 
     popup_width = std::max(popup_width, row_size);
   }
 
   return popup_width;
@@ skipping 25 matching lines @@
 
   return row_size;
 }
 
 void AutofillPopupControllerImpl::UpdatePopupBounds() {
   int popup_required_width = GetDesiredPopupWidth();
   int popup_height = GetDesiredPopupHeight();
   // This is the top left point of the popup if the popup is above the element
   // and grows to the left (since that is the highest and furthest left the
   // popup go could).
-  gfx::Point top_left_corner_of_popup = element_bounds().origin() +
-      gfx::Vector2d(element_bounds().width() - popup_required_width,
+  gfx::Point top_left_corner_of_popup = RoundedElementBounds().origin() +
+      gfx::Vector2d(RoundedElementBounds().width() - popup_required_width,
                     -popup_height);
 
   // This is the bottom right point of the popup if the popup is below the
   // element and grows to the right (since the is the lowest and furthest right
   // the popup could go).
-  gfx::Point bottom_right_corner_of_popup = element_bounds().origin() +
+  gfx::Point bottom_right_corner_of_popup = RoundedElementBounds().origin() +
       gfx::Vector2d(popup_required_width,
-                    element_bounds().height() + popup_height);
+                    RoundedElementBounds().height() + popup_height);
 
   gfx::Display top_left_display = GetDisplayNearestPoint(
       top_left_corner_of_popup);
   gfx::Display bottom_right_display = GetDisplayNearestPoint(
       bottom_right_corner_of_popup);
 
   std::pair<int, int> popup_x_and_width = CalculatePopupXAndWidth(
       top_left_display, bottom_right_display, popup_required_width);
   std::pair<int, int> popup_y_and_height = CalculatePopupYAndHeight(
       top_left_display, bottom_right_display, popup_height);
 
   popup_bounds_ = gfx::Rect(popup_x_and_width.first,
                             popup_y_and_height.first,
                             popup_x_and_width.second,
                             popup_y_and_height.second);
 }
 #endif  // !defined(OS_ANDROID)
 
+const gfx::Rect AutofillPopupControllerImpl::RoundedElementBounds() const {
+  return gfx::ToNearestRect(element_bounds_);
+}
+
 gfx::Display AutofillPopupControllerImpl::GetDisplayNearestPoint(
     const gfx::Point& point) const {
   return gfx::Screen::GetScreenFor(container_view())->GetDisplayNearestPoint(
       point);
 }
 
 std::pair<int, int> AutofillPopupControllerImpl::CalculatePopupXAndWidth(
     const gfx::Display& left_display,
     const gfx::Display& right_display,
     int popup_required_width) const {
   int leftmost_display_x = left_display.bounds().x() *
       left_display.device_scale_factor();
   int rightmost_display_x = right_display.GetSizeInPixel().width() +
       right_display.bounds().x() * right_display.device_scale_factor();
 
   // Calculate the start coordinates for the popup if it is growing right or
   // the end position if it is growing to the left, capped to screen space.
   int right_growth_start = std::max(leftmost_display_x,
                                     std::min(rightmost_display_x,
-                                             element_bounds().x()));
+                                             RoundedElementBounds().x()));
   int left_growth_end = std::max(leftmost_display_x,
                                    std::min(rightmost_display_x,
-                                            element_bounds().right()));
+                                            RoundedElementBounds().right()));
 
   int right_available = rightmost_display_x - right_growth_start;
   int left_available = left_growth_end - leftmost_display_x;
 
   int popup_width = std::min(popup_required_width,
                              std::max(right_available, left_available));
 
   // If there is enough space for the popup on the right, show it there,
   // otherwise choose the larger size.
   if (right_available >= popup_width || right_available >= left_available)
     return std::make_pair(right_growth_start, popup_width);
   else
     return std::make_pair(left_growth_end - popup_width, popup_width);
 }
 
 std::pair<int,int> AutofillPopupControllerImpl::CalculatePopupYAndHeight(
     const gfx::Display& top_display,
     const gfx::Display& bottom_display,
     int popup_required_height) const {
   int topmost_display_y = top_display.bounds().y() *
       top_display.device_scale_factor();
   int bottommost_display_y = bottom_display.GetSizeInPixel().height() +
       (bottom_display.bounds().y() *
        bottom_display.device_scale_factor());
 
   // Calculate the start coordinates for the popup if it is growing down or
   // the end position if it is growing up, capped to screen space.
   int top_growth_end = std::max(topmost_display_y,
                                 std::min(bottommost_display_y,
-                                         element_bounds().y()));
+                                         RoundedElementBounds().y()));
   int bottom_growth_start = std::max(topmost_display_y,
-                                     std::min(bottommost_display_y,
-                                              element_bounds().bottom()));
+      std::min(bottommost_display_y, RoundedElementBounds().bottom()));
 
   int top_available = bottom_growth_start - topmost_display_y;
   int bottom_available = bottommost_display_y - top_growth_end;
 
   // TODO(csharp): Restrict the popup height to what is available.
   if (bottom_available >= popup_required_height ||
       bottom_available >= top_available) {
     // The popup can appear below the field.
     return std::make_pair(bottom_growth_start, popup_required_height);
   } else {
     // The popup must appear above the field.
     return std::make_pair(top_growth_end - popup_required_height,
                           popup_required_height);
   }
 }