Uses and returns the fractional width in text eliding

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"
@@ skipping 104 matching lines @@
     const std::vector<string16>& names,
     const std::vector<string16>& subtexts,
     const std::vector<string16>& icons,
     const std::vector<int>& identifiers) {
   SetValues(names, subtexts, icons, identifiers);
 
 #if !defined(OS_ANDROID)
   // Android displays the long text with ellipsis using the view attributes.
 
   UpdatePopupBounds();
-  int popup_width = popup_bounds().width();
+  float popup_width = popup_bounds().width();
 
   // Elide the name and subtext strings so that the popup fits in the available
   // space.
   for (size_t i = 0; i < names_.size(); ++i) {
-    int name_width = GetNameFontForRow(i).GetStringWidth(names_[i]);
-    int subtext_width = subtext_font().GetStringWidth(subtexts_[i]);
-    int total_text_length = name_width + subtext_width;
+    float name_width = GetNameFontForRow(i).GetStringWidth(names_[i]);
+    float subtext_width = subtext_font().GetStringWidth(subtexts_[i]);
+    float total_text_length = name_width + subtext_width;
 
     // The line can have no strings if it represents a UI element, such as
     // a separator line.
     if (total_text_length == 0)
       continue;
 
-    int available_width = popup_width - RowWidthWithoutText(i);
+    float available_width = popup_width - RowWidthWithoutText(i);
 
     // Each field recieves space in proportion to its length.
-    int name_size = available_width * name_width / total_text_length;
+    float name_size = available_width * name_width / total_text_length;
     names_[i] = gfx::ElideText(names_[i],
                               GetNameFontForRow(i),
                               name_size,
                               gfx::ELIDE_AT_END);
 
-    int subtext_size = available_width * subtext_width / total_text_length;
+    float subtext_size = available_width * subtext_width / total_text_length;
     subtexts_[i] = gfx::ElideText(subtexts_[i],
                                  subtext_font(),
                                  subtext_size,
                                  gfx::ELIDE_AT_END);
   }
 #endif
 
   if (!view_) {
     view_ = AutofillPopupView::Create(this);
 
@@ skipping 169 matching lines @@
   int id = identifiers_[index];
   return id > 0 ||
       id == WebAutofillClient::MenuItemIDAutocompleteEntry ||
       id == WebAutofillClient::MenuItemIDPasswordEntry;
 }
 
 bool AutofillPopupControllerImpl::IsWarning(size_t index) const {
   return identifiers_[index] == WebAutofillClient::MenuItemIDWarningMessage;
 }
 
-gfx::Rect AutofillPopupControllerImpl::GetRowBounds(size_t index) {
+gfx::RectF AutofillPopupControllerImpl::GetRowBounds(size_t index) {
   int top = 0;
   for (size_t i = 0; i < index; ++i) {
     top += GetRowHeightFromId(identifiers()[i]);
   }
 
-  return gfx::Rect(
+  return gfx::RectF(
       0,
       top,
       popup_bounds_.width(),
       GetRowHeightFromId(identifiers()[index]));
 }
 
-void AutofillPopupControllerImpl::SetPopupBounds(const gfx::Rect& bounds) {
+void AutofillPopupControllerImpl::SetPopupBounds(const gfx::RectF& bounds) {
   popup_bounds_ = bounds;
   UpdateBoundsAndRedrawPopup();
 }
 
-const gfx::Rect& AutofillPopupControllerImpl::popup_bounds() const {
+const gfx::RectF& AutofillPopupControllerImpl::popup_bounds() const {
   return popup_bounds_;
 }
 
 gfx::NativeView AutofillPopupControllerImpl::container_view() const {
   return container_view_;
 }
 
 const gfx::RectF& AutofillPopupControllerImpl::element_bounds() const {
   return element_bounds_;
 }
@@ skipping 191 matching lines @@
   view_->Show();
 }
 
 void AutofillPopupControllerImpl::InvalidateRow(size_t row) {
   DCHECK(0 <= row);
   DCHECK(row < identifiers_.size());
   view_->InvalidateRow(row);
 }
 
 #if !defined(OS_ANDROID)
-int AutofillPopupControllerImpl::GetDesiredPopupWidth() const {
+float 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 = RoundedElementBounds().width();
+  float 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]) +
+    float 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;
 }
 
 int AutofillPopupControllerImpl::GetDesiredPopupHeight() const {
@@ skipping 16 matching lines @@
   if (!icons_[row].empty())
     row_size += kAutofillIconWidth + kIconPadding;
 
   // Add the padding at the end
   row_size += kEndPadding;
 
   return row_size;
 }
 
 void AutofillPopupControllerImpl::UpdatePopupBounds() {
-  int popup_required_width = GetDesiredPopupWidth();
+  float 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 = 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 = RoundedElementBounds().origin() +
       gfx::Vector2d(popup_required_width,
                     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(
+  std::pair<float, float> 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);
+  popup_bounds_ = gfx::RectF(popup_x_and_width.first,
+                             popup_y_and_height.first,
+                             popup_x_and_width.second,
+                             popup_y_and_height.second);
 }
 #endif  // !defined(OS_ANDROID)
 
 WeakPtr<AutofillPopupControllerImpl> AutofillPopupControllerImpl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void AutofillPopupControllerImpl::ClearState() {
   // Don't clear view_, because otherwise the popup will have to get regenerated
   // and this will cause flickering.
 
-  popup_bounds_ = gfx::Rect();
+  popup_bounds_ = gfx::RectF();
 
   names_.clear();
   subtexts_.clear();
   icons_.clear();
   identifiers_.clear();
   full_names_.clear();
 
   selected_line_ = kNoSelection;
 }
 
 const gfx::Rect AutofillPopupControllerImpl::RoundedElementBounds() const {
   return gfx::ToEnclosingRect(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(
+std::pair<float, float> AutofillPopupControllerImpl::CalculatePopupXAndWidth(
     const gfx::Display& left_display,
     const gfx::Display& right_display,
-    int popup_required_width) const {
+    float popup_required_width) const {
   int leftmost_display_x = left_display.bounds().x();
   int rightmost_display_x =
       right_display.GetSizeInPixel().width() + right_display.bounds().x();
 
   // 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,
                                              RoundedElementBounds().x()));
   int left_growth_end = std::max(leftmost_display_x,
                                    std::min(rightmost_display_x,
                                             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));
+  float popup_width = std::min<float>(
+      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(
@@ skipping 21 matching lines @@
     // 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);
   }
 }
 
 }  // namespace autofill