Elide text in the new Autofill UI

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/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;
 
 // Size difference between name and subtext in pixels.
 const int kLabelFontSizeDelta = -2;
@@ skipping 86 matching lines @@
     const std::vector<string16>& icons,
     const std::vector<int>& identifiers) {
   names_ = names;
   subtexts_ = subtexts;
   icons_ = icons;
   identifiers_ = identifiers;
 
 #if !defined(OS_ANDROID)
   // Android displays the long text with ellipsis using the view attributes.
 
-  // TODO(csharp): Fix crbug.com/156163 and use better logic when clipping.
+  UpdatePopupBounds();
+  int 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) {
-    if (names_[i].length() > 15)
-      names_[i].erase(15);
-    if (subtexts[i].length() > 15)
-      subtexts_[i].erase(15);
+    int name_width = name_font().GetStringWidth(names_[i]);
+    int subtext_width = subtext_font().GetStringWidth(subtexts_[i]);
+    int 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);
+
+    // Each field recieves space in proportion to its length.
+    int name_size = available_width * name_width / total_text_length;
+    names_[i] = ui::ElideText(names_[i],
+                              name_font(),
+                              name_size,
+                              ui::ELIDE_AT_END);
+
+    int subtext_size = available_width * subtext_width / total_text_length;
+    subtexts_[i] = ui::ElideText(subtexts_[i],
+                                 subtext_font(),
+                                 subtext_size,
+                                 ui::ELIDE_AT_END);
   }
 #endif
 
   if (!view_) {
     view_ = AutofillPopupView::Create(this);
     ShowView();
   } else {
     UpdateBoundsAndRedrawPopup();
   }
 }
 
 void AutofillPopupControllerImpl::Hide() {
   inform_delegate_of_destruction_ = false;
   HideInternal();
 }
 
 void AutofillPopupControllerImpl::ViewDestroyed() {
   delete this;
 }
 
 void AutofillPopupControllerImpl::UpdateBoundsAndRedrawPopup() {
 #if !defined(OS_ANDROID)
-  popup_bounds_.set_width(GetPopupRequiredWidth());
-  popup_bounds_.set_height(GetPopupRequiredHeight());
+  popup_bounds_.set_width(GetDesiredPopupWidth());
+  popup_bounds_.set_height(GetDesiredPopupHeight());

[Ilya Sherman, 2013/01/15 22:29:55]

This seems wrong.  Wouldn't it cause the popup to grow off the screen if it had
been shrunk to fit?

[csharp, 2013/01/16 20:56:58]

yup, fixed.

 #endif
 
   view_->UpdateBoundsAndRedrawPopup();
 }
 
 void AutofillPopupControllerImpl::MouseHovered(int x, int y) {
   SetSelectedLine(LineFromY(y));
 
   bool delete_icon_hovered = DeleteIconIsUnder(x, y);
   if (delete_icon_hovered != delete_icon_hovered_) {
@@ skipping 22 matching lines @@
 int AutofillPopupControllerImpl::GetIconResourceID(
     const string16& resource_name) {
   for (size_t i = 0; i < arraysize(kDataResources); ++i) {
     if (resource_name == ASCIIToUTF16(kDataResources[i].name))
       return kDataResources[i].id;
   }
 
   return -1;
 }
 
-bool AutofillPopupControllerImpl::CanDelete(size_t index) {
+bool AutofillPopupControllerImpl::CanDelete(size_t index) const {
   // TODO(isherman): AddressBook suggestions on Mac should not be drawn as
   // deleteable.
   int id = identifiers_[index];
   return id > 0 ||
       id == WebAutofillClient::MenuItemIDAutocompleteEntry ||
       id == WebAutofillClient::MenuItemIDPasswordEntry;
 }
 
-#if !defined(OS_ANDROID)
-int AutofillPopupControllerImpl::GetPopupRequiredWidth() {
-  if (name_font_.platform_font() == NULL ||
-      subtext_font_.platform_font() == NULL) {
-    // We can't calculate the size of the popup if the fonts
-    // aren't present.
-    return 0;
-  }
-
-  int popup_width = element_bounds().width();
-  DCHECK_EQ(names().size(), subtexts().size());
-  for (size_t i = 0; i < names().size(); ++i) {
-    int row_size = kEndPadding +
-        name_font_.GetStringWidth(names()[i]) +
-        kNamePadding +
-        subtext_font_.GetStringWidth(subtexts()[i]);
-
-    // Add the Autofill icon size, if required.
-    if (!icons()[i].empty())
-      row_size += kAutofillIconWidth + kIconPadding;
-
-    // Add delete icon, if required.
-    if (CanDelete(i))
-      row_size += kDeleteIconWidth + kIconPadding;
-
-    // Add the padding at the end
-    row_size += kEndPadding;
-
-    popup_width = std::max(popup_width, row_size);
-  }
-
-  return popup_width;
-}
-
-int AutofillPopupControllerImpl::GetPopupRequiredHeight() {
-  int popup_height = 0;
-
-  for (size_t i = 0; i < identifiers().size(); ++i) {
-    popup_height += GetRowHeightFromId(identifiers()[i]);
-  }
-
-  return popup_height;
-}
-#endif  // !defined(OS_ANDROID)
-
 gfx::Rect AutofillPopupControllerImpl::GetRowBounds(size_t index) {
   int top = 0;
   for (size_t i = 0; i < index; ++i) {
     top += GetRowHeightFromId(identifiers()[i]);
   }
 
   return gfx::Rect(
       0,
       top,
       popup_bounds_.width(),
@@ skipping 192 matching lines @@
     current_height += GetRowHeightFromId(identifiers()[i]);
 
     if (y <= current_height)
       return i;
   }
 
   // The y value goes beyond the popup so stop the selection at the last line.
   return identifiers().size() - 1;
 }
 
-int AutofillPopupControllerImpl::GetRowHeightFromId(int identifier) {
+int AutofillPopupControllerImpl::GetRowHeightFromId(int identifier) const {
   if (identifier == WebAutofillClient::MenuItemIDSeparator)
     return kSeparatorHeight;
 
   return kRowHeight;
 }
 
 bool AutofillPopupControllerImpl::DeleteIconIsUnder(int x, int y) {
 #if defined(OS_ANDROID)
   return false;
 #else
   if (!CanDelete(selected_line()))
     return false;
 
   int row_start_y = 0;
   for (int i = 0; i < selected_line(); ++i) {
     row_start_y += GetRowHeightFromId(identifiers()[i]);
   }
 
   gfx::Rect delete_icon_bounds = gfx::Rect(
-      GetPopupRequiredWidth() - kDeleteIconWidth - kIconPadding,
+      popup_bounds().width() - kDeleteIconWidth - kIconPadding,
       row_start_y + ((kRowHeight - kDeleteIconHeight) / 2),
       kDeleteIconWidth,
       kDeleteIconHeight);
 
   return delete_icon_bounds.Contains(x, y);
 #endif
 }
 
 bool AutofillPopupControllerImpl::CanAccept(int id) {
   return id != WebAutofillClient::MenuItemIDSeparator &&
       id != WebAutofillClient::MenuItemIDWarningMessage;
 }
 
 bool AutofillPopupControllerImpl::HasSuggestions() {
   return identifiers_.size() != 0 &&
       (identifiers_[0] > 0 ||
        identifiers_[0] ==
            WebAutofillClient::MenuItemIDAutocompleteEntry ||
        identifiers_[0] == WebAutofillClient::MenuItemIDPasswordEntry ||
        identifiers_[0] == WebAutofillClient::MenuItemIDDataListEntry);
 }
 
 void AutofillPopupControllerImpl::ShowView() {
   view_->Show();
 }
 
 void AutofillPopupControllerImpl::InvalidateRow(size_t row) {
   view_->InvalidateRow(row);
 }
+
+#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();
+  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;
+}
+
+int AutofillPopupControllerImpl::GetDesiredPopupHeight() const {
+  int popup_height = 0;
+
+  for (size_t i = 0; i < identifiers().size(); ++i) {
+    popup_height += GetRowHeightFromId(identifiers()[i]);
+  }
+
+  return popup_height;
+}
+
+int AutofillPopupControllerImpl::RowWidthWithoutText(int row) const {
+  int row_size = kEndPadding + kNamePadding;
+
+  // Add the Autofill icon size, if required.
+  if (!icons_[row].empty())
+    row_size += kAutofillIconWidth + kIconPadding;
+
+  // Add the delete icon size, if required.
+  if (CanDelete(row))
+    row_size += kDeleteIconWidth + kIconPadding;
+
+  // Add the padding at the end
+  row_size += kEndPadding;
+
+  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,
+                    -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::Vector2d(popup_required_width,
+                    element_bounds().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)
+
+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 leftmost and rightmost coordinates the popup can have without
+  // going off the screen.
+  int left_cutoff = std::max(element_bounds().origin().x(), leftmost_display_x);
+  int right_cutoff = std::min(element_bounds().top_right().x(),
+                              rightmost_display_x);
+
+  int right_available = rightmost_display_x - left_cutoff;
+  int left_available = right_cutoff - 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(left_cutoff, popup_width);
+  else
+    return std::make_pair(right_cutoff - 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 {
+  // Find the correct top position of the popup so that it doesn't go off
+  // the screen.
+  int bottom_display_y = bottom_display.GetSizeInPixel().height() +
+      (bottom_display.bounds().y() *
+       bottom_display.device_scale_factor());
+  int bottom_of_field = element_bounds().bottom();
+
+  if (bottom_display_y < bottom_of_field + popup_required_height) {
+    // The popup must appear above the field.
+    return std::make_pair(element_bounds().y() - popup_required_height,
+                          popup_required_height);
+  } else {
+    // The popup can appear below the field.
+    return std::make_pair(bottom_of_field, popup_required_height);
+  }
+}