Implement eliding/truncating at end in RenderText

ui/gfx/text_elider.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.
 //
 // This file implements utility functions for eliding and formatting UI text.
 //
 // Note that several of the functions declared in text_elider.h are implemented
 // in this file using helper classes in an unnamed namespace.
 
 #include "ui/gfx/text_elider.h"
@@ skipping 21 matching lines @@
 
 namespace gfx {
 
 // U+2026 in utf8
 const char kEllipsis[] = "\xE2\x80\xA6";
 const base::char16 kEllipsisUTF16[] = { 0x2026, 0 };
 const base::char16 kForwardSlash = '/';
 
 namespace {
 
-// Helper class to split + elide text, while respecting UTF16 surrogate pairs.
-class StringSlicer {
- public:
-  StringSlicer(const base::string16& text,
-               const base::string16& ellipsis,
-               bool elide_in_middle)
-      : text_(text),
-        ellipsis_(ellipsis),
-        elide_in_middle_(elide_in_middle) {
-  }
-
-  // Cuts |text_| to be |length| characters long. If |elide_in_middle_| is true,
-  // the middle of the string is removed to leave equal-length pieces from the
-  // beginning and end of the string; otherwise, the end of the string is
-  // removed and only the beginning remains. If |insert_ellipsis| is true,
-  // then an ellipsis character will be inserted at the cut point.
-  base::string16 CutString(size_t length, bool insert_ellipsis) {
-    const base::string16 ellipsis_text = insert_ellipsis ? ellipsis_
-                                                         : base::string16();
-
-    if (!elide_in_middle_)
-      return text_.substr(0, FindValidBoundaryBefore(length)) + ellipsis_text;
-
-    // We put the extra character, if any, before the cut.
-    const size_t half_length = length / 2;
-    const size_t prefix_length = FindValidBoundaryBefore(length - half_length);
-    const size_t suffix_start_guess = text_.length() - half_length;
-    const size_t suffix_start = FindValidBoundaryAfter(suffix_start_guess);
-    const size_t suffix_length =
-        half_length - (suffix_start_guess - suffix_start);
-    return text_.substr(0, prefix_length) + ellipsis_text +
-           text_.substr(suffix_start, suffix_length);
-  }
-
- private:
-  // Returns a valid cut boundary at or before |index|.
-  size_t FindValidBoundaryBefore(size_t index) const {
-    DCHECK_LE(index, text_.length());
-    if (index != text_.length())
-      U16_SET_CP_START(text_.data(), 0, index);
-    return index;
-  }
-
-  // Returns a valid cut boundary at or after |index|.
-  size_t FindValidBoundaryAfter(size_t index) const {
-    DCHECK_LE(index, text_.length());
-    if (index != text_.length())
-      U16_SET_CP_LIMIT(text_.data(), 0, index, text_.length());
-    return index;
-  }
-
-  // The text to be sliced.
-  const base::string16& text_;
-
-  // Ellipsis string to use.
-  const base::string16& ellipsis_;
-
-  // If true, the middle of the string will be elided.
-  bool elide_in_middle_;
-
-  DISALLOW_COPY_AND_ASSIGN(StringSlicer);
-};
 
 // Build a path from the first |num_components| elements in |path_elements|.
 // Prepends |path_prefix|, appends |filename|, inserts ellipsis if appropriate.
 base::string16 BuildPathFromComponents(
     const base::string16& path_prefix,
     const std::vector<base::string16>& path_elements,
     const base::string16& filename,
     size_t num_components) {
   // Add the initial elements of the path.
   base::string16 path = path_prefix;
@@ skipping 29 matching lines @@
     if (available_pixel_width >= GetStringWidthF(elided_path, font_list))
       return ElideText(elided_path + url_query, font_list,
                        available_pixel_width, ELIDE_AT_END);
   }
 
   return base::string16();
 }
 
 }  // namespace
 
+StringSlicer::StringSlicer(const base::string16& text,
+             const base::string16& ellipsis,
+             bool elide_in_middle)
+    : text_(text),
+      ellipsis_(ellipsis),
+      elide_in_middle_(elide_in_middle) {
+}
+
+base::string16 StringSlicer::CutString(size_t length, bool insert_ellipsis) {
+  const base::string16 ellipsis_text = insert_ellipsis ? ellipsis_
+                                                       : base::string16();
+
+  if (!elide_in_middle_)
+    return text_.substr(0, FindValidBoundaryBefore(length)) + ellipsis_text;
+
+  // We put the extra character, if any, before the cut.
+  const size_t half_length = length / 2;
+  const size_t prefix_length = FindValidBoundaryBefore(length - half_length);
+  const size_t suffix_start_guess = text_.length() - half_length;
+  const size_t suffix_start = FindValidBoundaryAfter(suffix_start_guess);
+  const size_t suffix_length =
+      half_length - (suffix_start_guess - suffix_start);
+  return text_.substr(0, prefix_length) + ellipsis_text +
+         text_.substr(suffix_start, suffix_length);
+}
+
+size_t StringSlicer::FindValidBoundaryBefore(size_t index) const {
+  DCHECK_LE(index, text_.length());
+  if (index != text_.length())
+    U16_SET_CP_START(text_.data(), 0, index);
+  return index;
+}
+
+size_t StringSlicer::FindValidBoundaryAfter(size_t index) const {
+  DCHECK_LE(index, text_.length());
+  if (index != text_.length())
+    U16_SET_CP_LIMIT(text_.data(), 0, index, text_.length());
+  return index;
+}
+
 base::string16 ElideEmail(const base::string16& email,
                           const FontList& font_list,
                           float available_pixel_width) {
   if (GetStringWidthF(email, font_list) <= available_pixel_width)
     return email;
 
   // Split the email into its local-part (username) and domain-part. The email
   // spec technically allows for @ symbols in the local-part (username) of the
   // email under some special requirements. It is guaranteed that there is no @
   // symbol in the domain part of the email however so splitting at the last @
@@ skipping 307 matching lines @@
 
   // 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()) {
-    const base::string16 cut = slicer.CutString(text.length() / 2, false);
+    const base::string16 cut =
+      slicer.CutString(text.length() / 2, insert_ellipsis);
     return ElideText(cut, font_list, available_pixel_width, elide_behavior);
   }
 
   if (current_text_pixel_width <= available_pixel_width)
     return text;
 
   if (insert_ellipsis &&
       GetStringWidthF(ellipsis, font_list) > available_pixel_width)
     return base::string16();
 
   // Use binary search to compute the elided text.
   size_t lo = 0;
   size_t hi = text.length() - 1;
   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
+    // We check the width of the whole desired string at once to ensure we
     // handle kerning/ligatures/etc. correctly.
     const base::string16 cut = slicer.CutString(guess, insert_ellipsis);
-    const float guess_length = GetStringWidthF(cut, font_list);
-    // 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(slicer.CutString(guess / 2, false),
-                       font_list, available_pixel_width, elide_behavior);
+    const float guess_width = GetStringWidthF(cut, font_list);
+    if (guess_width == available_pixel_width)
+      break;
+    if (guess_width > available_pixel_width) {
+      hi = guess - 1;
+      // Move back if we are on loop terminating condition, and guess is wider
+      // than available.
+      if (hi < lo)
+        lo = hi;
+    } else {
+      lo = guess + 1;
     }
-    if (guess_length > available_pixel_width)
-      hi = guess - 1;
-    else
-      lo = guess + 1;
   }
 
   return slicer.CutString(guess, insert_ellipsis);
 }
 
 base::string16 ElideText(const base::string16& text,
                          const Font& font,
                          float available_pixel_width,
                          ElideBehavior elide_behavior) {
   return ElideText(text, FontList(font), available_pixel_width, elide_behavior);
@@ skipping 618 matching lines @@
       index = char_iterator.getIndex();
     } else {
       // String has leading whitespace, return the elide string.
       return kElideString;
     }
   }
   return string.substr(0, index) + kElideString;
 }
 
 }  // namespace gfx