Clamp RenderTextWin layout length to 10,000 code points.

ui/base/text/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/base/text/text_elider.h"
@@ skipping 15 matching lines @@
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/icu/public/common/unicode/rbbi.h"
 #include "third_party/icu/public/common/unicode/uloc.h"
 #include "ui/gfx/font.h"
 
 namespace ui {
 
 // U+2026 in utf8
 const char kEllipsis[] = "\xE2\x80\xA6";
+const char16 kEllipsisUTF16[] = { 0x2026, 0 };
 const char16 kForwardSlash = '/';
 
 namespace {
 
 // Helper class to split + elide text, while respecting UTF16 surrogate pairs.
 class StringSlicer {
  public:
   StringSlicer(const string16& text,
                const string16& ellipsis,
                bool elide_in_middle)
@@ skipping 52 matching lines @@
 
   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.
 string16 BuildPathFromComponents(const string16& path_prefix,
                                  const std::vector<string16>& path_elements,
                                  const string16& filename,
                                  size_t num_components) {
-  const string16 kEllipsisAndSlash = UTF8ToUTF16(kEllipsis) + kForwardSlash;
-
   // Add the initial elements of the path.
   string16 path = path_prefix;
 
   // Build path from first |num_components| elements.
   for (size_t j = 0; j < num_components; ++j)
     path += path_elements[j] + kForwardSlash;
 
   // Add |filename|, ellipsis if necessary.
   if (num_components != (path_elements.size() - 1))
-    path += kEllipsisAndSlash;
+    path += UTF8ToUTF16(kEllipsis) + kForwardSlash;
   path += filename;
 
   return path;
 }
 
 // Takes a prefix (Domain, or Domain+subdomain) and a collection of path
 // components and elides if possible. Returns a string containing the longest
 // possible elided path, or an empty string if elision is not possible.
 string16 ElideComponentizedPath(const string16& url_path_prefix,
                                 const std::vector<string16>& url_path_elements,
                                 const string16& url_filename,
                                 const string16& url_query,
                                 const gfx::Font& font,
                                 int available_pixel_width) {
   const size_t url_path_number_of_elements = url_path_elements.size();
 
-  const string16 kEllipsisAndSlash = UTF8ToUTF16(kEllipsis) + kForwardSlash;
-
   CHECK(url_path_number_of_elements);
   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, ELIDE_AT_END);
   }
 
   return string16();
@@ skipping 12 matching lines @@
   // 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.
   const size_t split_index = email.find_last_of('@');
   DCHECK_NE(split_index, string16::npos);
   string16 username = email.substr(0, split_index);
   string16 domain = email.substr(split_index + 1);
   DCHECK(!username.empty());
   DCHECK(!domain.empty());
 
-  const string16 kEllipsisUTF16 = UTF8ToUTF16(kEllipsis);
-
   // Subtract the @ symbol from the available width as it is mandatory.
   const string16 kAtSignUTF16 = ASCIIToUTF16("@");
   available_pixel_width -= font.GetStringWidth(kAtSignUTF16);
 
   // Check whether eliding the domain is necessary: if eliding the username
   // is sufficient, the domain will not be elided.
   const int full_username_width = font.GetStringWidth(username);
   const int available_domain_width =
       available_pixel_width -
       std::min(full_username_width,
                font.GetStringWidth(username.substr(0, 1) + kEllipsisUTF16));
   if (font.GetStringWidth(domain) > available_domain_width) {
     // Elide the domain so that it only takes half of the available width.
     // Should the username not need all the width available in its half, the
     // domain will occupy the leftover width.
     // If |desired_domain_width| is greater than |available_domain_width|: the
     // minimal username elision allowed by the specifications will not fit; thus
     // |desired_domain_width| must be <= |available_domain_width| at all cost.
     const int desired_domain_width =
         std::min(available_domain_width,
                  std::max(available_pixel_width - full_username_width,
                           available_pixel_width / 2));
     domain = ElideText(domain, font, desired_domain_width, ELIDE_IN_MIDDLE);
     // Failing to elide the domain such that at least one character remains
     // (other than the ellipsis itself) remains: return a single ellipsis.
     if (domain.length() <= 1U)
-      return kEllipsisUTF16;
+      return 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).
   username = ElideText(username,
                        font,
                        available_pixel_width - font.GetStringWidth(domain),
                        ELIDE_AT_END);
 
@@ skipping 151 matching lines @@
   if (!elided_path.empty())
     return elided_path;
 
   // Check with only domain.
   // If a subdomain is present, add an ellipsis before domain.
   // This is added only if the subdomain pixel width is larger than
   // the pixel width of kEllipsis. Otherwise, subdomain remains,
   // which means that this case has been resolved earlier.
   string16 url_elided_domain = url_subdomain + url_domain;
   if (pixel_width_url_subdomain > kPixelWidthDotsTrailer) {
-    if (!url_subdomain.empty()) {
+    if (!url_subdomain.empty())
       url_elided_domain = kEllipsisAndSlash[0] + url_domain;
-    } else {
+    else
       url_elided_domain = url_domain;
-    }
 
     elided_path = ElideComponentizedPath(url_elided_domain, url_path_elements,
                                          url_filename, url_query, font,
                                          available_pixel_width);
 
     if (!elided_path.empty())
       return elided_path;
   }
 
   // Return elided domain/.../filename anyway.
@@ skipping 63 matching lines @@
   return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
 }
 
 string16 ElideText(const string16& text,
                    const gfx::Font& font,
                    int available_pixel_width,
                    ElideBehavior elide_behavior) {
   if (text.empty())
     return text;
 
-  const string16 kEllipsisUTF16 = UTF8ToUTF16(kEllipsis);
-
   const int current_text_pixel_width = font.GetStringWidth(text);
   const bool elide_in_middle = (elide_behavior == ELIDE_IN_MIDDLE);
   const bool insert_ellipsis = (elide_behavior != TRUNCATE_AT_END);
 
-  StringSlicer slicer(text, kEllipsisUTF16, elide_in_middle);
+  const string16 ellipsis = string16(kEllipsisUTF16);
+  StringSlicer slicer(text, ellipsis, elide_in_middle);
 
   // 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 string16 cut = slicer.CutString(text.length() / 2, false);
     return ElideText(cut, font, available_pixel_width, elide_behavior);
   }
 
   if (current_text_pixel_width <= available_pixel_width)
     return text;
 
-  if (insert_ellipsis &&
-      font.GetStringWidth(kEllipsisUTF16) > available_pixel_width)
+  if (insert_ellipsis && font.GetStringWidth(ellipsis) > available_pixel_width)
     return 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
     // handle kerning/ligatures/etc. correctly.
     const string16 cut = slicer.CutString(guess, insert_ellipsis);
@@ skipping 634 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