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) {
+#if defined(OS_ANDROID)

[msw, 2013/08/16 16:59:25]

I believe avoiding these platform-specific preprocessor blocks is precisely why
we use canvas_android|ios|mac|skia, etc.; let's keep it that way.

[Yuki, 2013/08/16 17:24:31]

Note that these defined(OS_ANDROID) appear only inside obsolete methods of
gfx::Font version.  And sooner or later they're removed.

Alexei suggested putting all obsolete methods in canvas.cc because they're just
redirection to new methods (and at that point they seemed platform-independent).
 Now I've realized that these redirection cause forces us to have stub code in
canvas_{android,ios,mac}.cc, otherwise it causes unresolved linkage errors.

I'm okay to move these obsolete redirection methods to
canvas_{android,ios,mac,skia}.cc.  They will be removed after all, and the goal
is the same.  However, in that case, we have the same redirection code here and
there.

With above note, which do you really want?
I'm okay with either way.

[msw, 2013/08/16 17:31:39]

If the obsolete redirection methods can be consolidated in canvas.cc and then
just stub out their underlying functions in platform-specific files where
canvas_skia isn't used, that sounds best. I don't quite follow why you'd need to
duplicate the redirection code. But this is just my opinion, if other reviewers
disagree, they should speak up.

[Yuki, 2013/08/16 18:29:28]

Okay, I'll leave the redirection code here in canvas.cc and add stub code in
canvas_{android,ios,mac,skia}.cc.

The drawback is that we need to put stub code (or real implementation) in every
platform's *.cc file, even if it's never called, otherwise it causes linkage
error.  Since we'll have stub code, it won't cause linkage error at compile-time
if we accidentally used such not-implemented stub methods.  Runtime error is
harder to handle than compile-time error, so I think this is drawback.

If we want to minimize the amount of such not-implemented stub code, an option
is to move the redirection code to each platofrm's *.cc file.  Then, we can omit
both redirection code and stub code for some methods on some platforms, and then
accidental use of not-implemented code causes linkage error.
This is what you asked why canvas_android.cc partially has stub code, not for
all methods.
Probably you don't care this point much at this time.

+  NOTIMPLEMENTED();
+#else
+  SizeStringInt(text, gfx::FontList(font), width, height, line_height, flags);
+#endif
+}
+
+// static
+int Canvas::GetStringWidth(const base::string16& text,
+                           const gfx::FontList& font_list) {
+#if defined(OS_ANDROID)
+  NOTIMPLEMENTED();
+  return 0;
+#else
+  int width = 0, height = 0;
+  SizeStringInt(text, font_list, &width, &height, 0, NO_ELLIPSIS);
+  return width;
+#endif
+}
+
+// static
 int Canvas::GetStringWidth(const base::string16& text, const gfx::Font& font) {
+#if defined(OS_ANDROID)
+  NOTIMPLEMENTED();
+  return 0;
+#else
   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;
+#endif
 }
 
 // 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) {
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  NOTIMPLEMENTED();
+#else
+  DrawStringWithHaloRect(text, gfx::FontList(font), text_color, halo_color_in,
+                         gfx::Rect(x, y, w, h), flags);
+#endif
+}
+
 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::DrawStringRect(const base::string16& text,
+                            const gfx::FontList& font_list,
+                            SkColor color,
+                            const gfx::Rect& display_rect) {
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  NOTIMPLEMENTED();
+#else
+  DrawStringWithFlagsRect(text, font_list, color, display_rect,
+                          DefaultCanvasTextAlignment());
+#endif
+}
+
+void Canvas::DrawStringWithFlagsRect(const base::string16& text,
+                                     const gfx::FontList& font_list,
+                                     SkColor color,
+                                     const gfx::Rect& display_rect,
+                                     int flags) {
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  NOTIMPLEMENTED();
+#else
+  DrawStringWithShadowsRect(text, font_list, color, display_rect, 0, flags,
+                            ShadowValues());
+#endif
+}
+
 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) {
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  NOTIMPLEMENTED();
+#else
+  DrawStringWithShadowsRect(text, gfx::FontList(font), color, text_bounds,
+                            line_height, flags, shadows);
+#endif
+}
+
 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) {
+#if defined(OS_ANDROID) || defined(OS_IOS) || defined(OS_MACOSX)
+  NOTIMPLEMENTED();
+#else
+  DrawFadeTruncatingStringRect(text, truncate_mode,
+                               desired_characters_to_truncate_from_head,
+                               gfx::FontList(font), color, display_rect);
+#endif
+}
+
 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