Move gfx::ElideText functionality to 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"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "ui/gfx/font_list.h"
+#include "ui/gfx/render_text.h"
 #include "ui/gfx/text_utils.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::WideToUTF16;
 
 namespace gfx {
 
 namespace {
 
-// Elides a well-formed email address (e.g. username@domain.com) to fit into
-// |available_pixel_width| using the specified |font_list|.
-// This function guarantees that the string returned will contain at least one
-// character, other than the ellipses, on either side of the '@'. If it is
-// impossible to achieve these requirements: only an ellipsis will be returned.
-// If possible: this elides only the username portion of the |email|. Otherwise,
-// the domain is elided in the middle so that it splits the available width
-// equally with the elided username (should the username be short enough that it
-// doesn't need half the available width: the elided domain will occupy that
-// extra width).
+#if !defined(OS_WIN) && !defined(OS_LINUX)
+// The returned string will have at least one character besides the ellipsis
+// on either side of '@'; if that's impossible, a single ellipsis is returned.
+// If possible, only the username is elided. Otherwise, the domain is elided
+// in the middle, splitting available width equally with the elided username.
+// If the username is short enough that it doesn't need half the available
+// width, the elided domain will occupy that extra width.
 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 @
-  // symbol is safe.
+  // spec allows for @ symbols in the username under some special requirements,
+  // but not in the domain part, so splitting at the last @ symbol is safe.
   const size_t split_index = email.find_last_of('@');
   DCHECK_NE(split_index, base::string16::npos);
   base::string16 username = email.substr(0, split_index);
   base::string16 domain = email.substr(split_index + 1);
   DCHECK(!username.empty());
   DCHECK(!domain.empty());
 
   // Subtract the @ symbol from the available width as it is mandatory.
   const base::string16 kAtSignUTF16 = ASCIIToUTF16("@");
   available_pixel_width -= GetStringWidthF(kAtSignUTF16, font_list);
@@ skipping 24 matching lines @@
       return base::string16(kEllipsisUTF16);
   }
 
   // Fit the username in the remaining width (at this point the elided username
   // is guaranteed to fit with at least one character remaining given all the
   // precautions taken earlier).
   available_pixel_width -= GetStringWidthF(domain, font_list);
   username = ElideText(username, font_list, available_pixel_width, ELIDE_TAIL);
   return username + kAtSignUTF16 + domain;
 }
+#endif
 
 }  // namespace
 
 // U+2026 in utf8
 const char kEllipsis[] = "\xE2\x80\xA6";
 const base::char16 kEllipsisUTF16[] = { 0x2026, 0 };
 const base::char16 kForwardSlash = '/';
 
 StringSlicer::StringSlicer(const base::string16& text,
                            const base::string16& ellipsis,
@@ skipping 86 matching lines @@
   base::string16 elided_name =
       ElideText(rootname, font_list, available_root_width, ELIDE_TAIL);
   elided_name += extension;
   return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
 }
 
 base::string16 ElideText(const base::string16& text,
                          const FontList& font_list,
                          float available_pixel_width,
                          ElideBehavior behavior) {
+#if defined(OS_WIN) || defined(OS_LINUX)

[Alexei Svitkine (slow), 2014/07/03 20:12:34]

I understand why it wouldn't work on platforms that don't have RenderText (e.g.
iOS), but why not Mac? afaik, eliding shouldn't be using any things
unimplemented by RenderTextMac.

[msw, 2014/07/08 19:07:36]

RenderText doesn't support RectF values for the display rect and failed some
unit tests. I ceil'ed the available  width and made GetContentWidth return float
values. That gets the tests passing, but might cause a non-integral available
width elision to assume use of the full pixel. Do you think I should attempt to
support RectF display rects in this CL (or as a prerequisite CL)?

   DCHECK_NE(behavior, FADE_TAIL);
-  if (text.empty() || behavior == FADE_TAIL)
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  render_text->SetCursorEnabled(false);
+  // Do not bother accurately sizing strings over 5000 characters here, for
+  // performance purposes. This matches the behavior of Canvas::SizeStringFloat.
+  render_text->set_truncate_length(5000);
+  render_text->SetFontList(font_list);
+  render_text->SetDisplayRect(gfx::Rect(gfx::Size(available_pixel_width, 1)));
+  render_text->SetElideBehavior(behavior);
+  render_text->SetText(text);
+  return render_text->layout_text();
+#else
+  DCHECK_NE(behavior, FADE_TAIL);
+  if (text.empty() || behavior == FADE_TAIL || behavior == NO_ELIDE ||
+      GetStringWidthF(text, font_list) <= available_pixel_width)

[Alexei Svitkine (slow), 2014/07/03 20:12:34]

Nit: {}'s

[msw, 2014/07/08 19:07:36]

Done.

     return text;
   if (behavior == ELIDE_EMAIL)
     return ElideEmail(text, font_list, available_pixel_width);
 
-  const float current_text_pixel_width = GetStringWidthF(text, font_list);
   const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
   const bool elide_at_beginning = (behavior == ELIDE_HEAD);
   const bool insert_ellipsis = (behavior != TRUNCATE);
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   StringSlicer slicer(text, ellipsis, elide_in_middle, elide_at_beginning);
 
-  // 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) {
-    const base::string16 cut =
-      slicer.CutString(text.length() / 2, insert_ellipsis);
-    return ElideText(cut, font_list, available_pixel_width, 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 width of the whole desired string at once to ensure we
     // handle kerning/ligatures/etc. correctly.
     // TODO(skanuj) : Handle directionality of ellipsis based on adjacent
     // characters.  See crbug.com/327963.
     const base::string16 cut = slicer.CutString(guess, insert_ellipsis);
     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.
+      // Move back on the loop terminating condition when the guess is too wide.
       if (hi < lo)
         lo = hi;
     } else {
       lo = guess + 1;
     }
   }
 
   return slicer.CutString(guess, insert_ellipsis);
+#endif
 }
 
 bool ElideString(const base::string16& input,
                  int max_len,
                  base::string16* output) {
   DCHECK_GE(max_len, 0);
   if (static_cast<int>(input.length()) <= max_len) {
     output->assign(input);
     return false;
   }
@@ skipping 539 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