Change signature of |ui::ElideText()|. Add a truncate mode.

ui/base/text/text_elider.cc

 // Copyright (c) 2011 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 "ui/base/text/text_elider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 76 matching lines @@
                                 int available_pixel_width) {
   size_t url_path_number_of_elements = url_path_elements.size();
 
   const string16 kEllipsisAndSlash = UTF8ToUTF16(kEllipsis) + kForwardSlash;
 
   for (size_t i = url_path_number_of_elements - 1; i > 0; --i) {
     string16 elided_path = BuildPathFromComponents(url_path_prefix,
         url_path_elements, url_filename, i);
     if (available_pixel_width >= font.GetStringWidth(elided_path))
       return ElideText(elided_path + url_query,
-          font, available_pixel_width, false);
+          font, available_pixel_width, ui::ELIDE_AT_END);
   }
 
   return string16();
 }
 
 }  // namespace
 
 // This function takes a GURL object and elides it. It returns a string
 // which composed of parts from subdomain, domain, path, filename and query.
 // A "..." is added automatically at the end if the elided string is bigger
@@ skipping 10 matching lines @@
                   const std::string& languages) {
   // Get a formatted string and corresponding parsing of the url.
   url_parse::Parsed parsed;
   string16 url_string = net::FormatUrl(url, languages, net::kFormatUrlOmitAll,
       net::UnescapeRule::SPACES, &parsed, NULL, NULL);
   if (available_pixel_width <= 0)
     return url_string;
 
   // If non-standard or not file type, return plain eliding.
   if (!(url.SchemeIsFile() || url.IsStandard()))
-    return ElideText(url_string, font, available_pixel_width, false);
+    return ElideText(url_string, font, available_pixel_width, ui::ELIDE_AT_END);
 
   // Now start eliding url_string to fit within available pixel width.
   // Fist pass - check to see whether entire url_string fits.
   int pixel_width_url_string = font.GetStringWidth(url_string);
   if (available_pixel_width >= pixel_width_url_string)
     return url_string;
 
   // Get the path substring, including query and reference.
   size_t path_start_index = parsed.path.begin;
   size_t path_len = parsed.path.len;
   string16 url_path_query_etc = url_string.substr(path_start_index);
   string16 url_path = url_string.substr(path_start_index, path_len);
 
   // Return general elided text if url minus the query fits.
   string16 url_minus_query = url_string.substr(0, path_start_index + path_len);
   if (available_pixel_width >= font.GetStringWidth(url_minus_query))
-    return ElideText(url_string, font, available_pixel_width, false);
+    return ElideText(url_string, font, available_pixel_width, ui::ELIDE_AT_END);
 
   // Get Host.
   string16 url_host = UTF8ToUTF16(url.host());
 
   // Get domain and registry information from the URL.
   string16 url_domain = UTF8ToUTF16(
       net::RegistryControlledDomainService::GetDomainAndRegistry(url));
   if (url_domain.empty())
     url_domain = url_host;
 
@@ skipping 50 matching lines @@
   // Query element.
   string16 url_query;
   const int kPixelWidthDotsTrailer =
       font.GetStringWidth(UTF8ToUTF16(kEllipsis));
   if (parsed.query.is_nonempty()) {
     url_query = UTF8ToUTF16("?") + url_string.substr(parsed.query.begin);
     if (available_pixel_width >= (pixel_width_url_subdomain +
         pixel_width_url_domain + pixel_width_url_path -
         font.GetStringWidth(url_query))) {
       return ElideText(url_subdomain + url_domain + url_path_query_etc,
-                       font, available_pixel_width, false);
+                       font, available_pixel_width, ui::ELIDE_AT_END);
     }
   }
 
   // Parse url_path using '/'.
   std::vector<string16> url_path_elements;
   base::SplitString(url_path, kForwardSlash, &url_path_elements);
 
   // Get filename - note that for a path ending with /
   // such as www.google.com/intl/ads/, the file name is ads/.
   size_t url_path_number_of_elements = url_path_elements.size();
   DCHECK(url_path_number_of_elements != 0);
   string16 url_filename;
   if ((url_path_elements.at(url_path_number_of_elements - 1)).length() > 0) {
     url_filename = *(url_path_elements.end() - 1);
   } else if (url_path_number_of_elements > 1) {  // Path ends with a '/'.
     url_filename = url_path_elements.at(url_path_number_of_elements - 2) +
         kForwardSlash;
     url_path_number_of_elements--;
   }
   DCHECK(url_path_number_of_elements != 0);
 
   const size_t kMaxNumberOfUrlPathElementsAllowed = 1024;
   if (url_path_number_of_elements <= 1 ||
       url_path_number_of_elements > kMaxNumberOfUrlPathElementsAllowed) {
     // No path to elide, or too long of a path (could overflow in loop below)
     // Just elide this as a text string.
     return ElideText(url_subdomain + url_domain + url_path_query_etc, font,
-                     available_pixel_width, false);
+                     available_pixel_width, ui::ELIDE_AT_END);
   }
 
   // Start eliding the path and replacing elements by ".../".
   const string16 kEllipsisAndSlash = UTF8ToUTF16(kEllipsis) + kForwardSlash;
   int pixel_width_ellipsis_slash = font.GetStringWidth(kEllipsisAndSlash);
 
   // Check with both subdomain and domain.
   string16 elided_path = ElideComponentizedPath(url_subdomain + url_domain,
       url_path_elements, url_filename, url_query, font, available_pixel_width);
   if (!elided_path.empty())
@@ skipping 26 matching lines @@
   // A hack to prevent trailing ".../...".
   if ((available_pixel_width - url_elided_domain_width) >
       pixel_width_ellipsis_slash + kPixelWidthDotsTrailer +
       font.GetStringWidth(ASCIIToUTF16("UV"))) {
     final_elided_url_string += BuildPathFromComponents(string16(),
         url_path_elements, url_filename, 1);
   } else {
     final_elided_url_string += url_path;
   }
 
-  return ElideText(final_elided_url_string, font, available_pixel_width, false);
+  return ElideText(final_elided_url_string, font, available_pixel_width,
+                   ui::ELIDE_AT_END);
 }
 
 string16 ElideFilename(const FilePath& filename,
                        const gfx::Font& font,
                        int available_pixel_width) {
 #if defined(OS_WIN)
   string16 filename_utf16 = filename.value();
   string16 extension = filename.Extension();
   string16 rootname = filename.BaseName().RemoveExtension().value();
 #elif defined(OS_POSIX)
   string16 filename_utf16 = WideToUTF16(base::SysNativeMBToWide(
       filename.value()));
   string16 extension = WideToUTF16(base::SysNativeMBToWide(
       filename.Extension()));
   string16 rootname = WideToUTF16(base::SysNativeMBToWide(
       filename.BaseName().RemoveExtension().value()));
 #endif
 
   int full_width = font.GetStringWidth(filename_utf16);
   if (full_width <= available_pixel_width)
     return base::i18n::GetDisplayStringInLTRDirectionality(filename_utf16);
 
   if (rootname.empty() || extension.empty()) {
     string16 elided_name = ElideText(filename_utf16, font,
-                                     available_pixel_width, false);
+                                     available_pixel_width, ui::ELIDE_AT_END);
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   int ext_width = font.GetStringWidth(extension);
   int root_width = font.GetStringWidth(rootname);
 
   // We may have trimmed the path.
   if (root_width + ext_width <= available_pixel_width) {
     string16 elided_name = rootname + extension;
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   if (ext_width >= available_pixel_width) {
     string16 elided_name = ElideText(rootname + extension, font,
-                                     available_pixel_width, true);
+                                     available_pixel_width,
+                                     ui::ELIDE_IN_MIDDLE);
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   int available_root_width = available_pixel_width - ext_width;
   string16 elided_name =
-      ElideText(rootname, font, available_root_width, false);
+      ElideText(rootname, font, available_root_width, ui::ELIDE_AT_END);
   elided_name += extension;
   return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
 }
 
 // This function adds an ellipsis at the end of the text if the text
 // does not fit the given pixel width.
 string16 ElideText(const string16& text,
                    const gfx::Font& font,
                    int available_pixel_width,
-                   bool elide_in_middle) {
+                   ElideBehavior elide_behavior) {
   if (text.empty())
     return text;
 
   int current_text_pixel_width = font.GetStringWidth(text);
+  bool elide_in_middle = (elide_behavior == ui::ELIDE_IN_MIDDLE);
+  bool insert_ellipsis = (elide_behavior != ui::TRUNCATE_AT_END);
 
   // Pango will return 0 width for absurdly long strings. Cut the string in
   // half and try again.
   // This is caused by an int overflow in Pango (specifically, in
   // pango_glyph_string_extents_range). It's actually more subtle than just
   // returning 0, since on super absurdly long strings, the int can wrap and
   // return positive numbers again. Detecting that is probably not worth it
   // (eliding way too much from a ridiculous string is probably still
   // ridiculous), but we should check other widths for bogus values as well.
   if (current_text_pixel_width <= 0 && !text.empty()) {
     return ElideText(CutString(text, text.length() / 2, elide_in_middle, false),
-                     font, available_pixel_width, false);
+                     font, available_pixel_width, elide_behavior);
   }
 
   if (current_text_pixel_width <= available_pixel_width)
     return text;
 
   if (font.GetStringWidth(UTF8ToUTF16(kEllipsis)) > available_pixel_width)
     return string16();
 
   // Use binary search to compute the elided text.
   size_t lo = 0;
   size_t hi = text.length() - 1;
-  for (size_t guess = (lo + hi) / 2; guess != lo; guess = (lo + hi) / 2) {
+  size_t guess;
+  for (guess = (lo + hi) / 2; lo <= hi; guess = (lo + hi) / 2) {
     // We check the length of the whole desired string at once to ensure we
     // handle kerning/ligatures/etc. correctly.
-    int guess_length = font.GetStringWidth(
-        CutString(text, guess, elide_in_middle, true));
+    string16 cut = CutString(text, guess, elide_in_middle, insert_ellipsis);
+    int guess_length = font.GetStringWidth(cut);
     // Check again that we didn't hit a Pango width overflow. If so, cut the
     // current string in half and start over.
     if (guess_length <= 0) {
       return ElideText(CutString(text, guess / 2, elide_in_middle, false),
-                       font, available_pixel_width, elide_in_middle);
+                       font, available_pixel_width, elide_behavior);
     }
     if (guess_length > available_pixel_width)
-      hi = guess;
+      hi = guess - 1;
     else
-      lo = guess;
+      lo = guess + 1;
   }
 
-  return CutString(text, lo, elide_in_middle, true);
+  return CutString(text, guess, elide_in_middle, insert_ellipsis);
 }
 
 SortedDisplayURL::SortedDisplayURL(const GURL& url,
                                    const std::string& languages) {
   net::AppendFormattedHost(url, languages, &sort_host_);
   string16 host_minus_www = net::StripWWW(sort_host_);
   url_parse::Parsed parsed;
   display_url_ = net::FormatUrl(url, languages,
       net::kFormatUrlOmitAll, net::UnescapeRule::SPACES, &parsed, &prefix_end_,
       NULL);
@@ skipping 166 matching lines @@
   size_t current_col_;
 
   // True when we do whitespace to newline conversions ourselves.
   bool strict_;
 
   // True when some of the input has been truncated.
   bool suppressed_;
 
   // String onto which the output is accumulated.
   string16* output_;
+
+  DISALLOW_COPY_AND_ASSIGN(RectangleString);
 };
 
 void RectangleString::AddString(const string16& input) {
   base::i18n::BreakIterator lines(input,
                                   base::i18n::BreakIterator::BREAK_NEWLINE);
   if (lines.Init()) {
     while (lines.Advance())
       AddLine(lines.GetString());
   } else {
     NOTREACHED() << "BreakIterator (lines) init failed";
@@ skipping 141 matching lines @@
       index = char_iterator.getIndex();
     } else {
       // String has leading whitespace, return the elide string.
       return kElideString;
     }
   }
   return string.substr(0, index) + kElideString;
 }
 
 }  // namespace ui