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

ui/base/text/text_elider.h

 // 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 defines utility functions for eliding and formatting UI text.
 
 #ifndef UI_BASE_TEXT_TEXT_ELIDER_H_
 #define UI_BASE_TEXT_TEXT_ELIDER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "third_party/icu/source/common/unicode/uchar.h"
 #include "third_party/icu/source/i18n/unicode/coll.h"
 #include "ui/base/ui_export.h"
-#include "ui/gfx/font.h"
 
 class GURL;
 
 namespace base {
 class FilePath;
 }
 
+namespace gfx {
+class Font;
+class FontList;
+}  // namespace gfx
+
 namespace ui {
 
 UI_EXPORT extern const char kEllipsis[];
 UI_EXPORT extern const char16 kEllipsisUTF16[];
 
 // Elides a well-formed email address (e.g. username@domain.com) to fit into
-// |available_pixel_width| using the specified |font|.
+// |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).
 UI_EXPORT string16 ElideEmail(const string16& email,
+                              const gfx::FontList& font_list,
+                              int available_pixel_width);
+// Obsolete version.  Use the above version which takes gfx::FontList.
+UI_EXPORT string16 ElideEmail(const string16& email,

[msw, 2013/08/13 17:39:22]

Our style guide discourages overloading functions, can you rename one of these?
Perhaps it'd be easiest to rename the new function something like
ElideEmailWithFontList. Then, in a followup CL, rename the old function
ElideEmailDeprecated and rename the new function ElideEmail. Same suggestion for
the other overloaded Elide* functions below.

[Yuki, 2013/08/14 15:42:16]

Renaming is really painful.  If we rename methods in a single CL, there are many
client code and we have to ask each owner to review the CL.  If something is
wrong in the CL and it's reverted, we have to ask the same owners to review
almost the same CL again.  I'd like to avoid such situation.

We can avoid such situation in the following way.
step 1.  Add ElideEmailWithFontList.
step 2.  Rewrite client code to call ElideEmailWithFontList.
    (This can be done with separating CL for each module/owner.)
step 3.  Remove old ElideEmail and add new FontList version of ElideEmail which
is the same as ElideEmailWithFontList.
step 4.  Rewrite client code to call new ElideEmailWithFontList.
    (This can be done with separating CL for each module/owner.)

It's possible.  However, I don't want to ask each owner to review renaming CLs
twice (in step 2 and 4).  I think it's painful for both of owners and me.

As you suggested, can I overload these methods until I rewrite all client of old
Font versions?  I won't leave these obsolete methods.

[msw, 2013/08/14 17:26:40]

I'd allow a strictly temporary overload, but you may need to convince others.

[Yuki, 2013/08/14 17:48:26]

Thanks.

To: other reviewers,

Please raise your hand if you really don't like (temporary) overloading.

                               const gfx::Font& font,
                               int available_pixel_width);
 
 // 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
 // than the |available_pixel_width|. For |available_pixel_width| == 0, a
 // formatted, but un-elided, string is returned. |languages| is a comma
 // separated list of ISO 639 language codes and is used to determine what
 // characters are understood by a user. It should come from
 // |prefs::kAcceptLanguages|.
 //
 // Note: in RTL locales, if the URL returned by this function is going to be
 // displayed in the UI, then it is likely that the string needs to be marked
 // as an LTR string (using base::i18n::WrapStringWithLTRFormatting()) so that it
 // is displayed properly in an RTL context. Please refer to
 // http://crbug.com/6487 for more information.
 UI_EXPORT string16 ElideUrl(const GURL& url,
+                            const gfx::FontList& font_list,
+                            int available_pixel_width,
+                            const std::string& languages);
+// Obsolete version.  Use the above version which takes gfx::FontList.
+UI_EXPORT string16 ElideUrl(const GURL& url,
                             const gfx::Font& font,
                             int available_pixel_width,
                             const std::string& languages);
 
 enum ElideBehavior {
   // Add ellipsis at the end of the string.
   ELIDE_AT_END,
   // Add ellipsis in the middle of the string.
   ELIDE_IN_MIDDLE,
   // Truncate the end of the string.
   TRUNCATE_AT_END
 };
 
 // Elides |text| to fit in |available_pixel_width| according to the specified
 // |elide_behavior|.
 UI_EXPORT string16 ElideText(const string16& text,
+                             const gfx::FontList& font_list,
+                             int available_pixel_width,
+                             ElideBehavior elide_behavior);
+// Obsolete version.  Use the above version which takes gfx::FontList.
+UI_EXPORT string16 ElideText(const string16& text,
                              const gfx::Font& font,
                              int available_pixel_width,
                              ElideBehavior elide_behavior);
 
 // Elide a filename to fit a given pixel width, with an emphasis on not hiding
 // the extension unless we have to. If filename contains a path, the path will
 // be removed if filename doesn't fit into available_pixel_width. The elided
 // filename is forced to have LTR directionality, which means that in RTL UI
 // the elided filename is wrapped with LRE (Left-To-Right Embedding) mark and
 // PDF (Pop Directional Formatting) mark.
 UI_EXPORT string16 ElideFilename(const base::FilePath& filename,
+                                 const gfx::FontList& font_list,
+                                 int available_pixel_width);
+// Obsolete version.  Use the above version which takes gfx::FontList.
+UI_EXPORT string16 ElideFilename(const base::FilePath& filename,
                                  const gfx::Font& font,
                                  int available_pixel_width);
 
 // SortedDisplayURL maintains a string from a URL suitable for display to the
 // use. SortedDisplayURL also provides a function used for comparing two
 // SortedDisplayURLs for use in visually ordering the SortedDisplayURLs.
 //
 // SortedDisplayURL is relatively cheap and supports value semantics.
 class UI_EXPORT SortedDisplayURL {
  public:
@@ skipping 77 matching lines @@
 // Indicates whether the |available_pixel_width| by |available_pixel_height|
 // rectangle passed to |ElideRectangleText()| had insufficient space to
 // accommodate the given |text|, leading to elision or truncation.
 enum ReformattingResultFlags {
   INSUFFICIENT_SPACE_HORIZONTAL = 1 << 0,
   INSUFFICIENT_SPACE_VERTICAL = 1 << 1,
 };
 
 // Reformats |text| into output vector |lines| so that the resulting text fits
 // into an |available_pixel_width| by |available_pixel_height| rectangle with
-// the specified |font|. Input newlines are respected, but lines that are too
-// long are broken into pieces. For words that are too wide to fit on a single
-// line, the wrapping behavior can be specified with the |wrap_behavior| param.
-// Returns a combination of |ReformattingResultFlags| that indicate whether the
-// given rectangle had insufficient space to accommodate |texŧ|, leading to
-// elision or truncation (and not just reformatting).
+// the specified |font_list|. Input newlines are respected, but lines that are
+// too long are broken into pieces. For words that are too wide to fit on a
+// single line, the wrapping behavior can be specified with the |wrap_behavior|
+// param. Returns a combination of |ReformattingResultFlags| that indicate
+// whether the given rectangle had insufficient space to accommodate |texŧ|,
+// leading to elision or truncation (and not just reformatting).
+UI_EXPORT int ElideRectangleText(const string16& text,
+                                 const gfx::FontList& font_list,
+                                 int available_pixel_width,
+                                 int available_pixel_height,
+                                 WordWrapBehavior wrap_behavior,
+                                 std::vector<string16>* lines);
+// Obsolete version.  Use the above version which takes gfx::FontList.
 UI_EXPORT int ElideRectangleText(const string16& text,
                                  const gfx::Font& font,
                                  int available_pixel_width,
                                  int available_pixel_height,
                                  WordWrapBehavior wrap_behavior,
                                  std::vector<string16>* lines);
 
 // Truncates the string to length characters. This breaks the string at
 // the first word break before length, adding the horizontal ellipsis
 // character (unicode character 0x2026) to render ...
 // The supplied string is returned if the string has length characters or
 // less.
 UI_EXPORT string16 TruncateString(const string16& string, size_t length);
 
 }  // namespace ui
 
 #endif  // UI_BASE_TEXT_TEXT_ELIDER_H_