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

ui/gfx/canvas.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.
 
 #ifndef UI_GFX_CANVAS_H_
 #define UI_GFX_CANVAS_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/refptr.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/shadow_value.h"
 
 namespace gfx {
 
 class Rect;
 class Font;
+class FontList;
 class Point;
 class Size;
 class Transform;
 
 // Canvas is a SkCanvas wrapper that provides a number of methods for
 // common operations used throughout an application built using ui/gfx.
 //
 // All methods that take integer arguments (as is used throughout views)
 // end with Int. If you need to use methods provided by SkCanvas, you'll
 // need to do a conversion. In particular you'll need to use |SkIntToScalar()|,
@@ skipping 81 matching lines @@
   // Recreates the backing platform canvas with DIP |size| and |scale_factor|.
   // If the canvas is not opaque, it is explicitly cleared.
   // This method is public so that canvas_skia_paint can recreate the platform
   // canvas after having initialized the canvas.
   // TODO(pkotwicz): Push the scale factor into skia::PlatformCanvas such that
   // this method can be private.
   void RecreateBackingCanvas(const gfx::Size& size,
                              ui::ScaleFactor scale_factor,
                              bool is_opaque);
 
-  // Compute the size required to draw some text with the provided font.
+  // Compute the size required to draw some text with the provided fonts.
   // Attempts to fit the text with the provided width and height. Increases
   // height and then width as needed to make the text fit. This method
   // supports multiple lines. On Skia only a line_height can be specified and
   // specifying a 0 value for it will cause the default height to be used.
   static void SizeStringInt(const base::string16& text,
+                            const gfx::FontList& font_list,
+                            int* width, int* height,

[Alexei Svitkine (slow), 2013/08/12 18:16:21]

Nit: can you fix this to be 1 param per line, per style guide. Here and below.

[Yuki, 2013/08/13 09:32:13]

Done.

+                            int line_height,
+                            int flags);
+  // Obsolete version.  Use the above version which takes gfx::FontList.
+  static void SizeStringInt(const base::string16& text,
                             const gfx::Font& font,
                             int* width, int* height,
                             int line_height,
                             int flags);
 
   // Returns the number of horizontal pixels needed to display the specified
-  // |text| with |font|.
+  // |text| with |font_list|.
+  static int GetStringWidth(const base::string16& text,
+                            const gfx::FontList& font_list);
+  // Obsolete version.  Use the above version which takes gfx::FontList.
   static int GetStringWidth(const base::string16& text, const gfx::Font& font);
 
   // Returns the default text alignment to be used when drawing text on a
   // gfx::Canvas based on the directionality of the system locale language.
   // This function is used by gfx::Canvas::DrawStringInt when the text alignment
   // is not specified.
   //
   // This function returns either gfx::Canvas::TEXT_ALIGN_LEFT or
   // gfx::Canvas::TEXT_ALIGN_RIGHT.
   static int DefaultCanvasTextAlignment();
 
   // Draws text with a 1-pixel halo around it of the given color.
-  // On Windows, it allows ClearType to be drawn to an otherwise transparenct
+  // On Windows, it allows ClearType to be drawn to an otherwise transparent
   //   bitmap for drag images. Drag images have only 1-bit of transparency, so
   //   we don't do any fancy blurring.
   // On Linux, text with halo is created by stroking it with 2px |halo_color|
   //   then filling it with |text_color|.
   // On Mac, NOTIMPLEMENTED.
   //   TODO(dhollowa): Skia-native implementation is underway.  Cut over to
   //   that when ready.  http::/crbug.com/109946
   void DrawStringWithHalo(const base::string16& text,
+                          const gfx::FontList& font_list,
+                          SkColor text_color,
+                          SkColor halo_color,
+                          const Rect& display_rect,
+                          int flags);
+  // Obsolete version.  Use the above version which takes gfx::FontList.
+  void DrawStringWithHalo(const base::string16& text,
                           const gfx::Font& font,
                           SkColor text_color,
                           SkColor halo_color,
                           int x, int y, int w, int h,
                           int flags);
 
   // Extracts an ImageSkiaRep from the contents of this canvas.
   gfx::ImageSkiaRep ExtractImageRep() const;
 
   // Draws a dashed rectangle of the specified color.
@@ skipping 127 matching lines @@
   // Draws an |image| with the top left corner at |x| and |y|, clipped to
   // |path|.
   // Parameters are specified relative to current canvas scale not in pixels.
   // Thus, x is 2 pixels if canvas scale = 2 & |x| = 1.
   void DrawImageInPath(const gfx::ImageSkia& image,
                        int x,
                        int y,
                        const SkPath& path,
                        const SkPaint& paint);
 
-  // Draws text with the specified color, font and location. The text is
+  // Draws text with the specified color, fonts and location. The text is
   // aligned to the left, vertically centered, clipped to the region. If the
   // text is too big, it is truncated and '...' is added to the end.
+  void DrawString(const base::string16& text,
+                  const gfx::FontList& font_list,
+                  SkColor color,
+                  const gfx::Rect& display_rect);
+  // Obsolete versions.  Use the above versions which take gfx::FontList.
   void DrawStringInt(const base::string16& text,
                      const gfx::Font& font,
                      SkColor color,
                      int x, int y, int w, int h);
   void DrawStringInt(const base::string16& text,
                      const gfx::Font& font,
                      SkColor color,
                      const gfx::Rect& display_rect);
 
-  // Draws text with the specified color, font and location. The last argument
+  // Draws text with the specified color, fonts and location. The last argument
   // specifies flags for how the text should be rendered. It can be one of
   // TEXT_ALIGN_CENTER, TEXT_ALIGN_RIGHT or TEXT_ALIGN_LEFT.
+  void DrawStringWithAligned(const base::string16& text,

[Alexei Svitkine (slow), 2013/08/12 18:16:21]

Flags can specify more than just alignment. How about DrawStringWithFlags?

[Yuki, 2013/08/13 09:32:13]

Done.

+                             const gfx::FontList& font_list,
+                             SkColor color,
+                             const gfx::Rect& display_rect,
+                             int flags);
+  // Obsolete version.  Use the above version which takes gfx::FontList.
   void DrawStringInt(const base::string16& text,
                      const gfx::Font& font,
                      SkColor color,
                      int x, int y, int w, int h,
                      int flags);
 
   // Similar to above DrawStringInt method but with text shadows support.
   // Currently it's only implemented for canvas skia. Specifying a 0 line_height
   // will cause the default height to be used.
   void DrawStringWithShadows(const base::string16& text,
+                             const gfx::FontList& font_list,
+                             SkColor color,
+                             const gfx::Rect& text_bounds,
+                             int line_height,
+                             int flags,
+                             const ShadowValues& shadows);
+  // Obsolete version.  Use the above version which takes gfx::FontList.
+  void DrawStringWithShadows(const base::string16& text,
                              const gfx::Font& font,
                              SkColor color,
                              const gfx::Rect& text_bounds,
                              int line_height,
                              int flags,
                              const ShadowValues& shadows);
 
   // Draws a dotted gray rectangle used for focus purposes.
   void DrawFocusRect(const gfx::Rect& rect);
 
@@ skipping 22 matching lines @@
   void Transform(const gfx::Transform& transform);
 
   // Draws the given string with the beginning and/or the end using a fade
   // gradient. When truncating the head
   // |desired_characters_to_truncate_from_head| specifies the maximum number of
   // characters that can be truncated.
   void DrawFadeTruncatingString(
       const base::string16& text,
       TruncateFadeMode truncate_mode,
       size_t desired_characters_to_truncate_from_head,
+      const gfx::FontList& font_list,
+      SkColor color,
+      const gfx::Rect& display_rect);
+  // Obsolete version.  Use the above version which takes gfx::FontList.
+  void DrawFadeTruncatingString(
+      const base::string16& text,
+      TruncateFadeMode truncate_mode,
+      size_t desired_characters_to_truncate_from_head,
       const gfx::Font& font,
       SkColor color,
       const gfx::Rect& display_rect);
 
   skia::PlatformCanvas* platform_canvas() const { return owned_canvas_.get(); }
   SkCanvas* sk_canvas() const { return canvas_; }
   ui::ScaleFactor scale_factor() const { return scale_factor_; }
 
  private:
   Canvas(SkCanvas* canvas, ui::ScaleFactor scale_factor);
@@ skipping 21 matching lines @@
 
   skia::RefPtr<skia::PlatformCanvas> owned_canvas_;
   SkCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(Canvas);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_CANVAS_H_