Supports gfx::FontList in gfx::Canvas and ui::ElideText family.

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"
 
 #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 "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
-#include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
+#include "ui/gfx/text_utils.h"
 #include "url/gurl.h"
 
 namespace ui {
 
 // U+2026 in utf8
 const char kEllipsis[] = "\xE2\x80\xA6";
 const char16 kEllipsisUTF16[] = { 0x2026, 0 };
 const char16 kForwardSlash = '/';
 
 namespace {
@@ skipping 68 matching lines @@
                                  size_t num_components) {
   // 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 += UTF8ToUTF16(kEllipsis) + kForwardSlash;
+    path += string16(kEllipsisUTF16) + 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,
+                                const gfx::FontList& font_list,
                                 int available_pixel_width) {
   const size_t url_path_number_of_elements = url_path_elements.size();
 
   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);
+    if (available_pixel_width >= gfx::GetStringWidth(elided_path, font_list))
+      return ElideText(elided_path + url_query, font_list,
+                       available_pixel_width, ELIDE_AT_END);
   }
 
   return string16();
 }
 
 }  // namespace
 
 string16 ElideEmail(const string16& email,
-                    const gfx::Font& font,
+                    const gfx::FontList& font_list,
                     int available_pixel_width) {
-  if (font.GetStringWidth(email) <= available_pixel_width)
+  if (gfx::GetStringWidth(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.
   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());
 
   // Subtract the @ symbol from the available width as it is mandatory.
   const string16 kAtSignUTF16 = ASCIIToUTF16("@");
-  available_pixel_width -= font.GetStringWidth(kAtSignUTF16);
+  available_pixel_width -= gfx::GetStringWidth(kAtSignUTF16, font_list);
 
   // 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 full_username_width = gfx::GetStringWidth(username, font_list);
   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) {
+               gfx::GetStringWidth(username.substr(0, 1) + kEllipsisUTF16,
+                                   font_list));
+  if (gfx::GetStringWidth(domain, font_list) > 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);
+    domain = ElideText(domain, font_list, 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 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),
+  available_pixel_width -= gfx::GetStringWidth(domain, font_list);
+  username = ElideText(username, font_list, available_pixel_width,
                        ELIDE_AT_END);
 
   return username + kAtSignUTF16 + domain;
 }
 
+string16 ElideEmail(const string16& email,
+                    const gfx::Font& font,
+                    int available_pixel_width) {
+  return ElideEmail(email, gfx::FontList(font), available_pixel_width);
+}
+
 // TODO(pkasting): http://crbug.com/77883 This whole function gets
 // kerning/ligatures/etc. issues potentially wrong by assuming that the width of
 // a rendered string is always the sum of the widths of its substrings.  Also I
 // suspect it could be made simpler.
 string16 ElideUrl(const GURL& url,
-                  const gfx::Font& font,
+                  const gfx::FontList& font_list,
                   int available_pixel_width,
                   const std::string& languages) {
   // Get a formatted string and corresponding parsing of the url.
   url_parse::Parsed parsed;
   const 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, return plain eliding.
   if (!url.IsStandard())
-    return ElideText(url_string, font, available_pixel_width, ELIDE_AT_END);
+    return ElideText(url_string, font_list, available_pixel_width,
+                     ELIDE_AT_END);
 
   // Now start eliding url_string to fit within available pixel width.
   // Fist pass - check to see whether entire url_string fits.
-  const int pixel_width_url_string = font.GetStringWidth(url_string);
+  const int pixel_width_url_string = gfx::GetStringWidth(url_string, font_list);
   if (available_pixel_width >= pixel_width_url_string)
     return url_string;
 
   // Get the path substring, including query and reference.
   const size_t path_start_index = parsed.path.begin;
   const 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.
   const 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, ELIDE_AT_END);
+  if (available_pixel_width >= gfx::GetStringWidth(url_minus_query, font_list))
+    return ElideText(url_string, font_list, available_pixel_width,
+                     ELIDE_AT_END);
 
   // Get Host.
   string16 url_host = UTF8ToUTF16(url.host());
 
   // Get domain and registry information from the URL.
   string16 url_domain = UTF8ToUTF16(
       net::registry_controlled_domains::GetDomainAndRegistry(
           url, net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES));
   if (url_domain.empty())
     url_domain = url_host;
@@ skipping 27 matching lines @@
       url_domain.clear();
       url_subdomain.clear();
 
       const string16 kColon = UTF8ToUTF16(":");
       url_host = url_domain = file_path_split.at(0).substr(1) + kColon;
       url_path_query_etc = url_path = file_path_split.at(1);
     }
   }
 
   // Second Pass - remove scheme - the rest fits.
-  const int pixel_width_url_host = font.GetStringWidth(url_host);
-  const int pixel_width_url_path = font.GetStringWidth(url_path_query_etc);
+  const int pixel_width_url_host = gfx::GetStringWidth(url_host, font_list);
+  const int pixel_width_url_path = gfx::GetStringWidth(url_path_query_etc,
+                                                       font_list);
   if (available_pixel_width >=
       pixel_width_url_host + pixel_width_url_path)
     return url_host + url_path_query_etc;
 
   // Third Pass: Subdomain, domain and entire path fits.
-  const int pixel_width_url_domain = font.GetStringWidth(url_domain);
-  const int pixel_width_url_subdomain = font.GetStringWidth(url_subdomain);
+  const int pixel_width_url_domain = gfx::GetStringWidth(url_domain, font_list);
+  const int pixel_width_url_subdomain = gfx::GetStringWidth(url_subdomain,
+                                                            font_list);
   if (available_pixel_width >=
       pixel_width_url_subdomain + pixel_width_url_domain +
       pixel_width_url_path)
     return url_subdomain + url_domain + url_path_query_etc;
 
   // Query element.
   string16 url_query;
-  const int kPixelWidthDotsTrailer =
-      font.GetStringWidth(UTF8ToUTF16(kEllipsis));
+  const int kPixelWidthDotsTrailer = gfx::GetStringWidth(
+      string16(kEllipsisUTF16), font_list);
   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))) {
+    if (available_pixel_width >=
+        (pixel_width_url_subdomain + pixel_width_url_domain +
+         pixel_width_url_path - gfx::GetStringWidth(url_query, font_list))) {
       return ElideText(url_subdomain + url_domain + url_path_query_etc,
-                       font, available_pixel_width, ELIDE_AT_END);
+                       font_list, available_pixel_width, 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,
+    return ElideText(url_subdomain + url_domain + url_path_query_etc, font_list,
                      available_pixel_width, ELIDE_AT_END);
   }
 
   // Start eliding the path and replacing elements by ".../".
-  const string16 kEllipsisAndSlash = UTF8ToUTF16(kEllipsis) + kForwardSlash;
-  const int pixel_width_ellipsis_slash = font.GetStringWidth(kEllipsisAndSlash);
+  const string16 kEllipsisAndSlash = string16(kEllipsisUTF16) + kForwardSlash;
+  const int pixel_width_ellipsis_slash = gfx::GetStringWidth(kEllipsisAndSlash,
+                                                             font_list);
 
   // Check with both subdomain and domain.
   string16 elided_path =
       ElideComponentizedPath(url_subdomain + url_domain, url_path_elements,
-                             url_filename, url_query, font,
+                             url_filename, url_query, font_list,
                              available_pixel_width);
   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())
       url_elided_domain = kEllipsisAndSlash[0] + url_domain;
     else
       url_elided_domain = url_domain;
 
     elided_path = ElideComponentizedPath(url_elided_domain, url_path_elements,
-                                         url_filename, url_query, font,
+                                         url_filename, url_query, font_list,
                                          available_pixel_width);
 
     if (!elided_path.empty())
       return elided_path;
   }
 
   // Return elided domain/.../filename anyway.
   string16 final_elided_url_string(url_elided_domain);
-  const int url_elided_domain_width = font.GetStringWidth(url_elided_domain);
+  const int url_elided_domain_width = gfx::GetStringWidth(url_elided_domain,
+                                                          font_list);
 
   // A hack to prevent trailing ".../...".
   if ((available_pixel_width - url_elided_domain_width) >
       pixel_width_ellipsis_slash + kPixelWidthDotsTrailer +
-      font.GetStringWidth(ASCIIToUTF16("UV"))) {
+      gfx::GetStringWidth(ASCIIToUTF16("UV"), font_list)) {
     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,
+  return ElideText(final_elided_url_string, font_list, available_pixel_width,
                    ELIDE_AT_END);
 }
 
+string16 ElideUrl(const GURL& url,
+                  const gfx::Font& font,
+                  int available_pixel_width,
+                  const std::string& languages) {
+  return ElideUrl(url, gfx::FontList(font), available_pixel_width, languages);
+}
+
 string16 ElideFilename(const base::FilePath& filename,
-                       const gfx::Font& font,
+                       const gfx::FontList& font_list,
                        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
 
-  const int full_width = font.GetStringWidth(filename_utf16);
+  const int full_width = gfx::GetStringWidth(filename_utf16, font_list);
   if (full_width <= available_pixel_width)
     return base::i18n::GetDisplayStringInLTRDirectionality(filename_utf16);
 
   if (rootname.empty() || extension.empty()) {
-    const string16 elided_name = ElideText(filename_utf16, font,
+    const string16 elided_name = ElideText(filename_utf16, font_list,
                                            available_pixel_width, ELIDE_AT_END);
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
-  const int ext_width = font.GetStringWidth(extension);
-  const int root_width = font.GetStringWidth(rootname);
+  const int ext_width = gfx::GetStringWidth(extension, font_list);
+  const int root_width = gfx::GetStringWidth(rootname, font_list);
 
   // We may have trimmed the path.
   if (root_width + ext_width <= available_pixel_width) {
     const string16 elided_name = rootname + extension;
     return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
   }
 
   if (ext_width >= available_pixel_width) {
-    const string16 elided_name = ElideText(rootname + extension, font,
+    const string16 elided_name = ElideText(rootname + extension, font_list,
                                            available_pixel_width,
                                            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, ELIDE_AT_END);
+      ElideText(rootname, font_list, available_root_width, ELIDE_AT_END);
   elided_name += extension;
   return base::i18n::GetDisplayStringInLTRDirectionality(elided_name);
 }
 
+string16 ElideFilename(const base::FilePath& filename,
+                       const gfx::Font& font,
+                       int available_pixel_width) {
+  return ElideFilename(filename, gfx::FontList(font), available_pixel_width);
+}
+
 string16 ElideText(const string16& text,
-                   const gfx::Font& font,
+                   const gfx::FontList& font_list,
                    int available_pixel_width,
                    ElideBehavior elide_behavior) {
   if (text.empty())
     return text;
 
-  const int current_text_pixel_width = font.GetStringWidth(text);
+  const int current_text_pixel_width = gfx::GetStringWidth(text, font_list);
   const bool elide_in_middle = (elide_behavior == ELIDE_IN_MIDDLE);
   const bool insert_ellipsis = (elide_behavior != TRUNCATE_AT_END);
 
   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);
+    return ElideText(cut, font_list, available_pixel_width, elide_behavior);
   }
 
   if (current_text_pixel_width <= available_pixel_width)
     return text;
 
-  if (insert_ellipsis && font.GetStringWidth(ellipsis) > available_pixel_width)
+  if (insert_ellipsis &&
+      gfx::GetStringWidth(ellipsis, font_list) > 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);
-    const int guess_length = font.GetStringWidth(cut);
+    const int guess_length = gfx::GetStringWidth(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, available_pixel_width, elide_behavior);
+                       font_list, available_pixel_width, elide_behavior);
     }
     if (guess_length > available_pixel_width)
       hi = guess - 1;
     else
       lo = guess + 1;
   }
 
   return slicer.CutString(guess, insert_ellipsis);
 }
 
+string16 ElideText(const string16& text,
+                   const gfx::Font& font,
+                   int available_pixel_width,
+                   ElideBehavior elide_behavior) {
+  return ElideText(text, gfx::FontList(font), available_pixel_width,
+                   elide_behavior);
+}
+
 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);
   if (sort_host_.length() > host_minus_www.length()) {
     prefix_end_ += sort_host_.length() - host_minus_www.length();
@@ skipping 256 matching lines @@
   }
   ++current_row_;
   current_col_ = 0;
 }
 
 // Internal class used to track progress of a rectangular text elide
 // operation.  Exists so the top-level ElideRectangleText() function
 // can be broken into smaller methods sharing this state.
 class RectangleText {
  public:
-  RectangleText(const gfx::Font& font,
+  RectangleText(const gfx::FontList& font_list,
                 int available_pixel_width,
                 int available_pixel_height,
                 ui::WordWrapBehavior wrap_behavior,
                 std::vector<string16>* lines)
-      : font_(font),
-        line_height_(font.GetHeight()),
+      : font_list_(font_list),
+        line_height_(font_list.GetHeight()),
         available_pixel_width_(available_pixel_width),
         available_pixel_height_(available_pixel_height),
         wrap_behavior_(wrap_behavior),
         current_width_(0),
         current_height_(0),
         last_line_ended_in_lf_(false),
         lines_(lines),
         insufficient_width_(false),
         insufficient_height_(false) {}
 
@@ skipping 31 matching lines @@
   // running width by the specified amount. This is an optimization over
   // |AddToCurrentLine()| when |text_width| is already known.
   void AddToCurrentLineWithWidth(const string16& text, int text_width);
 
   // Append the specified |text| to the current output line.
   void AddToCurrentLine(const string16& text);
 
   // Set the current position to the beginning of the next line.
   bool NewLine();
 
-  // The font used for measuring text width.
-  const gfx::Font& font_;
+  // The font list used for measuring text width.
+  const gfx::FontList& font_list_;
 
   // The height of each line of text.
   const int line_height_;
 
   // The number of pixels of available width in the rectangle.
   const int available_pixel_width_;
 
   // The number of pixels of available height in the rectangle.
   const int available_pixel_height_;
 
@@ skipping 52 matching lines @@
     if (lines_->back().empty() && !last_line_ended_in_lf_)
       lines_->pop_back();
   }
   if (last_line_ended_in_lf_)
     lines_->push_back(string16());
   return (insufficient_width_ ? ui::INSUFFICIENT_SPACE_HORIZONTAL : 0) |
          (insufficient_height_ ? ui::INSUFFICIENT_SPACE_VERTICAL : 0);
 }
 
 void RectangleText::AddLine(const string16& line) {
-  const int line_width = font_.GetStringWidth(line);
+  const int line_width = gfx::GetStringWidth(line, font_list_);
   if (line_width <= available_pixel_width_) {
     AddToCurrentLineWithWidth(line, line_width);
   } else {
     // Iterate over positions that are valid to break the line at. In general,
     // these are word boundaries but after any punctuation following the word.
     base::i18n::BreakIterator words(line,
                                     base::i18n::BreakIterator::BREAK_LINE);
     if (words.Init()) {
       while (words.Advance()) {
         const bool truncate = !current_line_.empty();
@@ skipping 20 matching lines @@
   NewLine();
 }
 
 int RectangleText::WrapWord(const string16& word) {
   // Word is so wide that it must be fragmented.
   string16 text = word;
   int lines_added = 0;
   bool first_fragment = true;
   while (!insufficient_height_ && !text.empty()) {
     string16 fragment =
-        ui::ElideText(text, font_, available_pixel_width_, ui::TRUNCATE_AT_END);
+        ui::ElideText(text, font_list_, available_pixel_width_,
+                      ui::TRUNCATE_AT_END);
     // At least one character has to be added at every line, even if the
     // available space is too small.
     if(fragment.empty())
       fragment = text.substr(0, 1);
     if (!first_fragment && NewLine())
       lines_added++;
     AddToCurrentLine(fragment);
     text = text.substr(fragment.length());
     first_fragment = false;
   }
@@ skipping 13 matching lines @@
   if (wrap_behavior_ == ui::IGNORE_LONG_WORDS) {
     current_line_ = word;
     current_width_ = available_pixel_width_;
   } else if (wrap_behavior_ == ui::WRAP_LONG_WORDS) {
     lines_added += WrapWord(word);
   } else {
     const ui::ElideBehavior elide_behavior =
         (wrap_behavior_ == ui::ELIDE_LONG_WORDS ? ui::ELIDE_AT_END :
                                                   ui::TRUNCATE_AT_END);
     const string16 elided_word =
-        ui::ElideText(word, font_, available_pixel_width_, elide_behavior);
+        ui::ElideText(word, font_list_, available_pixel_width_, elide_behavior);
     AddToCurrentLine(elided_word);
     insufficient_width_ = true;
   }
 
   return lines_added;
 }
 
 int RectangleText::AddWord(const string16& word) {
   int lines_added = 0;
   string16 trimmed;
   TrimWhitespace(word, TRIM_TRAILING, &trimmed);
-  const int trimmed_width = font_.GetStringWidth(trimmed);
+  const int trimmed_width = gfx::GetStringWidth(trimmed, font_list_);
   if (trimmed_width <= available_pixel_width_) {
     // Word can be made to fit, no need to fragment it.
     if ((current_width_ + trimmed_width > available_pixel_width_) && NewLine())
       lines_added++;
     // Append the non-trimmed word, in case more words are added after.
     AddToCurrentLine(word);
   } else {
     lines_added = AddWordOverflow(wrap_behavior_ == ui::IGNORE_LONG_WORDS ?
                                   trimmed : word);
   }
   return lines_added;
 }
 
 void RectangleText::AddToCurrentLine(const string16& text) {
-  AddToCurrentLineWithWidth(text, font_.GetStringWidth(text));
+  AddToCurrentLineWithWidth(text, gfx::GetStringWidth(text, font_list_));
 }
 
 void RectangleText::AddToCurrentLineWithWidth(const string16& text,
                                               int text_width) {
   if (current_height_ >= available_pixel_height_) {
     insufficient_height_ = true;
     return;
   }
   current_line_.append(text);
   current_width_ += text_width;
@@ skipping 19 matching lines @@
 
 bool ElideRectangleString(const string16& input, size_t max_rows,
                           size_t max_cols, bool strict, string16* output) {
   RectangleString rect(max_rows, max_cols, strict, output);
   rect.Init();
   rect.AddString(input);
   return rect.Finalize();
 }
 
 int ElideRectangleText(const string16& input,
-                        const gfx::Font& font,
-                        int available_pixel_width,
-                        int available_pixel_height,
-                        WordWrapBehavior wrap_behavior,
-                        std::vector<string16>* lines) {
-  RectangleText rect(font,
+                       const gfx::FontList& font_list,
+                       int available_pixel_width,
+                       int available_pixel_height,
+                       WordWrapBehavior wrap_behavior,
+                       std::vector<string16>* lines) {
+  RectangleText rect(font_list,
                      available_pixel_width,
                      available_pixel_height,
                      wrap_behavior,
                      lines);
   rect.Init();
   rect.AddString(input);
   return rect.Finalize();
 }
 
+int ElideRectangleText(const string16& input,
+                       const gfx::Font& font,
+                       int available_pixel_width,
+                       int available_pixel_height,
+                       WordWrapBehavior wrap_behavior,
+                       std::vector<string16>* lines) {
+  return ElideRectangleText(input, gfx::FontList(font),
+                            available_pixel_width, available_pixel_height,
+                            wrap_behavior, lines);
+}
+
 string16 TruncateString(const string16& string, size_t length) {
   if (string.size() <= length)
     // String fits, return it.
     return string;
 
   if (length == 0)
     // No room for the elide string, return an empty string.
     return string16();
 
   size_t max = length - 1;
@@ skipping 43 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