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

ui/gfx/canvas.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.
 
 #include "ui/gfx/canvas.h"
 
 #include <limits>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/font.h"
+#include "ui/gfx/font_list.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/canvas_skia_paint.h"
 #endif
 
 namespace gfx {
@@ skipping 55 matching lines @@
       gfx::ScaleSize(size, ui::GetScaleFactorScale(scale_factor)));
   owned_canvas_ = skia::AdoptRef(skia::CreatePlatformCanvas(pixel_size.width(),
                                                             pixel_size.height(),
                                                             is_opaque));
   canvas_ = owned_canvas_.get();
   SkScalar scale = SkFloatToScalar(ui::GetScaleFactorScale(scale_factor_));
   canvas_->scale(scale, scale);
 }
 
 // static
+void Canvas::SizeStringInt(const base::string16& text,
+                           const gfx::Font& font,
+                           int* width,
+                           int* height,
+                           int line_height,
+                           int flags) {
+  SizeStringInt(text, gfx::FontList(font), width, height, line_height, flags);
+}
+
+// static
+int Canvas::GetStringWidth(const base::string16& text,
+                           const gfx::FontList& font_list) {
+  int width = 0, height = 0;
+  SizeStringInt(text, font_list, &width, &height, 0, NO_ELLIPSIS);
+  return width;
+}
+
+// static
 int Canvas::GetStringWidth(const base::string16& text, const gfx::Font& font) {
   int width = 0, height = 0;
-  Canvas::SizeStringInt(text, font, &width, &height, 0, NO_ELLIPSIS);
+  SizeStringInt(text, gfx::FontList(font), &width, &height, 0, NO_ELLIPSIS);
   return width;
 }
 
 // static
 int Canvas::DefaultCanvasTextAlignment() {
   return base::i18n::IsRTL() ? TEXT_ALIGN_RIGHT : TEXT_ALIGN_LEFT;
 }
 
+void Canvas::DrawStringWithHalo(const base::string16& text,
+                                const gfx::Font& font,
+                                SkColor text_color,
+                                SkColor halo_color_in,
+                                int x,
+                                int y,
+                                int w,
+                                int h,
+                                int flags) {
+  DrawStringWithHalo(text, gfx::FontList(font), text_color, halo_color_in,
+                     gfx::Rect(x, y, w, h), flags);
+}
+
 gfx::ImageSkiaRep Canvas::ExtractImageRep() const {
   const SkBitmap& device_bitmap = canvas_->getDevice()->accessBitmap(false);
 
   // Make a bitmap to return, and a canvas to draw into it. We don't just want
   // to call extractSubset or the copy constructor, since we want an actual copy
   // of the bitmap.
   SkBitmap result;
   device_bitmap.copyTo(&result, SkBitmap::kARGB_8888_Config);
 
   return gfx::ImageSkiaRep(result, scale_factor_);
@@ skipping 179 matching lines @@
   DrawImageInt(image, x, y, paint);
 }
 
 void Canvas::DrawImageInt(const gfx::ImageSkia& image, int x, int y, uint8 a) {
   SkPaint paint;
   paint.setAlpha(a);
   DrawImageInt(image, x, y, paint);
 }
 
 void Canvas::DrawImageInt(const gfx::ImageSkia& image,
-                          int x, int y,
+                          int x,
+                          int y,
                           const SkPaint& paint) {
   const gfx::ImageSkiaRep& image_rep = GetImageRepToPaint(image);
   if (image_rep.is_null())
     return;
   const SkBitmap& bitmap = image_rep.sk_bitmap();
   float bitmap_scale = image_rep.GetScale();
 
   canvas_->save();
   canvas_->scale(SkFloatToScalar(1.0f / bitmap_scale),
                  SkFloatToScalar(1.0f / bitmap_scale));
   canvas_->drawBitmap(bitmap,
                       SkFloatToScalar(x * bitmap_scale),
                       SkFloatToScalar(y * bitmap_scale),
                       &paint);
   canvas_->restore();
 }
 
 void Canvas::DrawImageInt(const gfx::ImageSkia& image,
-                          int src_x, int src_y, int src_w, int src_h,
-                          int dest_x, int dest_y, int dest_w, int dest_h,
+                          int src_x,
+                          int src_y,
+                          int src_w,
+                          int src_h,
+                          int dest_x,
+                          int dest_y,
+                          int dest_w,
+                          int dest_h,
                           bool filter) {
   SkPaint p;
   DrawImageInt(image, src_x, src_y, src_w, src_h, dest_x, dest_y,
                dest_w, dest_h, filter, p);
 }
 
 void Canvas::DrawImageInt(const gfx::ImageSkia& image,
-                          int src_x, int src_y, int src_w, int src_h,
-                          int dest_x, int dest_y, int dest_w, int dest_h,
+                          int src_x,
+                          int src_y,
+                          int src_w,
+                          int src_h,
+                          int dest_x,
+                          int dest_y,
+                          int dest_w,
+                          int dest_h,
                           bool filter,
                           const SkPaint& paint) {
   DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
               src_y + src_h < std::numeric_limits<int16_t>::max());
   if (src_w <= 0 || src_h <= 0) {
     NOTREACHED() << "Attempting to draw bitmap from an empty rect!";
     return;
   }
 
   if (!IntersectsClipRectInt(dest_x, dest_y, dest_w, dest_h))
@@ skipping 62 matching lines @@
   skia::RefPtr<SkShader> shader = gfx::CreateImageRepShader(
       image_rep,
       SkShader::kRepeat_TileMode,
       matrix);
 
   SkPaint p(paint);
   p.setShader(shader.get());
   canvas_->drawPath(path, p);
 }
 
+void Canvas::DrawString(const base::string16& text,
+                        const gfx::FontList& font_list,
+                        SkColor color,
+                        const gfx::Rect& display_rect) {
+  DrawStringWithFlags(text, font_list, color, display_rect,
+                      DefaultCanvasTextAlignment());
+}
+
+void Canvas::DrawStringWithFlags(const base::string16& text,
+                                 const gfx::FontList& font_list,
+                                 SkColor color,
+                                 const gfx::Rect& display_rect,
+                                 int flags) {
+  DrawStringWithShadows(text, font_list, color, display_rect, 0, flags,
+                        ShadowValues());
+}
+
 void Canvas::DrawStringInt(const base::string16& text,
                            const gfx::Font& font,
                            SkColor color,
-                           int x, int y, int w, int h) {
+                           int x,
+                           int y,
+                           int w,
+                           int h) {
   DrawStringInt(text, font, color, x, y, w, h, DefaultCanvasTextAlignment());
 }
 
 void Canvas::DrawStringInt(const base::string16& text,
                            const gfx::Font& font,
                            SkColor color,
                            const gfx::Rect& display_rect) {
   DrawStringInt(text, font, color, display_rect.x(), display_rect.y(),
                 display_rect.width(), display_rect.height());
 }
 
 void Canvas::DrawStringInt(const base::string16& text,
                            const gfx::Font& font,
                            SkColor color,
-                           int x, int y, int w, int h,
+                           int x,
+                           int y,
+                           int w,
+                           int h,
                            int flags) {
-  DrawStringWithShadows(text,
-                        font,
-                        color,
-                        gfx::Rect(x, y, w, h),
-                        0,
-                        flags,
+  DrawStringWithShadows(text, font, color, gfx::Rect(x, y, w, h), 0, flags,
                         ShadowValues());
 }
 
+void Canvas::DrawStringWithShadows(const base::string16& text,
+                                   const gfx::Font& font,
+                                   SkColor color,
+                                   const gfx::Rect& text_bounds,
+                                   int line_height,
+                                   int flags,
+                                   const ShadowValues& shadows) {
+  DrawStringWithShadows(text, gfx::FontList(font), color, text_bounds,
+                        line_height, flags, shadows);
+}
+
 void Canvas::TileImageInt(const gfx::ImageSkia& image,
-                          int x, int y, int w, int h) {
+                          int x,
+                          int y,
+                          int w,
+                          int h) {
   TileImageInt(image, 0, 0, x, y, w, h);
 }
 
 void Canvas::TileImageInt(const gfx::ImageSkia& image,
-                          int src_x, int src_y,
-                          int dest_x, int dest_y, int w, int h) {
+                          int src_x,
+                          int src_y,
+                          int dest_x,
+                          int dest_y,
+                          int w,
+                          int h) {
   TileImageInt(image, src_x, src_y, 1.0f, 1.0f, dest_x, dest_y, w, h);
 }
 
 void Canvas::TileImageInt(const gfx::ImageSkia& image,
-                          int src_x, int src_y,
-                          float tile_scale_x, float tile_scale_y,
-                          int dest_x, int dest_y, int w, int h) {
+                          int src_x,
+                          int src_y,
+                          float tile_scale_x,
+                          float tile_scale_y,
+                          int dest_x,
+                          int dest_y,
+                          int w,
+                          int h) {
   if (!IntersectsClipRectInt(dest_x, dest_y, w, h))
     return;
 
   const gfx::ImageSkiaRep& image_rep = GetImageRepToPaint(image,
       tile_scale_x, tile_scale_y);
   if (image_rep.is_null())
     return;
 
   SkMatrix shader_scale;
   shader_scale.setScale(SkFloatToScalar(tile_scale_x),
@@ skipping 22 matching lines @@
 }
 
 void Canvas::EndPlatformPaint() {
   skia::EndPlatformPaint(canvas_);
 }
 
 void Canvas::Transform(const gfx::Transform& transform) {
   canvas_->concat(transform.matrix());
 }
 
+void Canvas::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) {
+  DrawFadeTruncatingString(text, truncate_mode,
+                           desired_characters_to_truncate_from_head,
+                           gfx::FontList(font), color, display_rect);
+}
+
 Canvas::Canvas(SkCanvas* canvas, ui::ScaleFactor scale_factor)
     : scale_factor_(scale_factor),
       owned_canvas_(),
       canvas_(canvas) {
   DCHECK(canvas);
 }
 
 bool Canvas::IntersectsClipRectInt(int x, int y, int w, int h) {
   SkRect clip;
   return canvas_->getClipBounds(&clip) &&
@@ skipping 26 matching lines @@
 
     float bitmap_scale = image_rep.GetScale();
     if (scale_x < bitmap_scale || scale_y < bitmap_scale)
       const_cast<SkBitmap&>(image_rep.sk_bitmap()).buildMipMap();
   }
 
   return image_rep;
 }
 
 }  // namespace gfx