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

ui/gfx/canvas_skia.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 "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/range/range.h"
 #include "ui/base/text/text_elider.h"
-#include "ui/gfx/font.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/gfx/text_utils.h"
 
 namespace gfx {
 
 namespace {
@@ skipping 27 matching lines @@
   // default directionality is LTR, so the text doesn't need to be wrapped.
   // Note that individual runs within the string may still be rendered RTL
   // (which will be the case for RTL text under non-RTL locales, since under RTL
   // locales it will be handled by the if statement above).
   return false;
 }
 
 // Checks each pixel immediately adjacent to the given pixel in the bitmap. If
 // any of them are not the halo color, returns true. This defines the halo of
 // pixels that will appear around the text. Note that we have to check each
-// pixel against both the halo color and transparent since |DrawStringWithHalo|
-// will modify the bitmap as it goes, and cleared pixels shouldn't count as
-// changed.
+// pixel against both the halo color and transparent since
+// |DrawStringWithHaloRect| will modify the bitmap as it goes, and cleared
+// pixels shouldn't count as changed.
 bool PixelShouldGetHalo(const SkBitmap& bitmap,
                         int x, int y,
                         SkColor halo_color) {
   if (x > 0 &&
       *bitmap.getAddr32(x - 1, y) != halo_color &&
       *bitmap.getAddr32(x - 1, y) != 0)
     return true;  // Touched pixel to the left.
   if (x < bitmap.width() - 1 &&
       *bitmap.getAddr32(x + 1, y) != halo_color &&
       *bitmap.getAddr32(x + 1, y) != 0)
@@ skipping 18 matching lines @@
     int char_span = 0;
     *text = RemoveAcceleratorChar(*text, '&', &char_pos, &char_span);
     if ((flags & Canvas::SHOW_PREFIX) && char_pos != -1)
       return ui::Range(char_pos, char_pos + char_span);
   }
   return ui::Range::InvalidRange();
 }
 
 // Elides |text| and adjusts |range| appropriately. If eliding causes |range|
 // to no longer point to the same character in |text|, |range| is made invalid.
-void ElideTextAndAdjustRange(const Font& font,
+void ElideTextAndAdjustRange(const FontList& font_list,
                              int width,
                              base::string16* text,
                              ui::Range* range) {
   const base::char16 start_char =
       (range->IsValid() ? text->at(range->start()) : 0);
-  *text = ui::ElideText(*text, font, width, ui::ELIDE_AT_END);
+  *text = ui::ElideText(*text, font_list, width, ui::ELIDE_AT_END);
   if (!range->IsValid())
     return;
   if (range->start() >= text->length() ||
       text->at(range->start()) != start_char) {
     *range = ui::Range::InvalidRange();
   }
 }
 
 // Updates |render_text| from the specified parameters.
 void UpdateRenderText(const Rect& rect,
                       const base::string16& text,
-                      const Font& font,
+                      const FontList& font_list,
                       int flags,
                       SkColor color,
                       RenderText* render_text) {
-  render_text->SetFont(font);
+  render_text->SetFontList(font_list);
   render_text->SetText(text);
   render_text->SetCursorEnabled(false);
 
   Rect display_rect = rect;
-  display_rect.set_height(font.GetHeight());
+  display_rect.set_height(font_list.GetHeight());
   render_text->SetDisplayRect(display_rect);
 
   // Set the text alignment explicitly based on the directionality of the UI,
   // if not specified.
   if (!(flags & (Canvas::TEXT_ALIGN_CENTER |
                  Canvas::TEXT_ALIGN_RIGHT |
                  Canvas::TEXT_ALIGN_LEFT))) {
     flags |= Canvas::DefaultCanvasTextAlignment();
   }
 
   if (flags & Canvas::TEXT_ALIGN_RIGHT)
     render_text->SetHorizontalAlignment(ALIGN_RIGHT);
   else if (flags & Canvas::TEXT_ALIGN_CENTER)
     render_text->SetHorizontalAlignment(ALIGN_CENTER);
   else
     render_text->SetHorizontalAlignment(ALIGN_LEFT);
 
   if (flags & Canvas::NO_SUBPIXEL_RENDERING)
     render_text->set_background_is_transparent(true);
 
   render_text->SetColor(color);
-  render_text->SetStyle(BOLD, (font.GetStyle() & Font::BOLD) != 0);
-  render_text->SetStyle(ITALIC, (font.GetStyle() & Font::ITALIC) != 0);
-  render_text->SetStyle(UNDERLINE, (font.GetStyle() & Font::UNDERLINE) != 0);
+  const int font_style = font_list.GetFontStyle();
+  render_text->SetStyle(BOLD, (font_style & Font::BOLD) != 0);
+  render_text->SetStyle(ITALIC, (font_style & Font::ITALIC) != 0);
+  render_text->SetStyle(UNDERLINE, (font_style & Font::UNDERLINE) != 0);
 }
 
 // Returns updated |flags| to match platform-specific expected behavior.
 int AdjustPlatformSpecificFlags(const base::string16& text, int flags) {
 #if defined(OS_LINUX)
   // TODO(asvitkine): ash/tooltips/tooltip_controller.cc adds \n's to the string
   //                  without passing MULTI_LINE.
   if (text.find('\n') != base::string16::npos)
     flags |= Canvas::MULTI_LINE;
 #endif
 
   return flags;
 }
 
 }  // namespace
 
 // static
 void Canvas::SizeStringInt(const base::string16& text,
-                           const Font& font,
+                           const FontList& font_list,
                            int* width, int* height,
                            int line_height,
                            int flags) {
   DCHECK_GE(*width, 0);
   DCHECK_GE(*height, 0);
 
   flags = AdjustPlatformSpecificFlags(text, flags);
 
   base::string16 adjusted_text = text;
 #if defined(OS_WIN)
   AdjustStringDirection(flags, &adjusted_text);
 #endif
 
   if ((flags & MULTI_LINE) && *width != 0) {
     ui::WordWrapBehavior wrap_behavior = ui::TRUNCATE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = ui::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
       wrap_behavior = ui::ELIDE_LONG_WORDS;
 
     Rect rect(*width, INT_MAX);
     std::vector<base::string16> strings;
-    ui::ElideRectangleText(adjusted_text, font, rect.width(), rect.height(),
+    ui::ElideRectangleText(adjusted_text, font_list,
+                           rect.width(), rect.height(),
                            wrap_behavior, &strings);
     scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
-    UpdateRenderText(rect, base::string16(), font, flags, 0, render_text.get());
+    UpdateRenderText(rect, base::string16(), font_list, flags, 0,
+                     render_text.get());
 
     int h = 0;
     int w = 0;
     for (size_t i = 0; i < strings.size(); ++i) {
       StripAcceleratorChars(flags, &strings[i]);
       render_text->SetText(strings[i]);
-      const Size string_size = render_text->GetStringSize();
+      const Size& string_size = render_text->GetStringSize();
       w = std::max(w, string_size.width());
       h += (i > 0 && line_height > 0) ? line_height : string_size.height();
     }
     *width = w;
     *height = h;
   } else {
     // If the string is too long, the call by |RenderTextWin| to |ScriptShape()|
     // will inexplicably fail with result E_INVALIDARG. Guard against this.
     const size_t kMaxRenderTextLength = 5000;
     if (adjusted_text.length() >= kMaxRenderTextLength) {
-      *width = adjusted_text.length() * font.GetAverageCharacterWidth();
-      *height = font.GetHeight();
+      *width = font_list.GetExpectedTextWidth(adjusted_text.length());
+      *height = font_list.GetHeight();
     } else {
       scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
       Rect rect(*width, *height);
       StripAcceleratorChars(flags, &adjusted_text);
-      UpdateRenderText(rect, adjusted_text, font, flags, 0, render_text.get());
-      const Size string_size = render_text->GetStringSize();
+      UpdateRenderText(rect, adjusted_text, font_list, flags, 0,
+                       render_text.get());
+      const Size& string_size = render_text->GetStringSize();
       *width = string_size.width();
       *height = string_size.height();
     }
   }
 }
 
-void Canvas::DrawStringWithShadows(const base::string16& text,
-                                   const Font& font,
-                                   SkColor color,
-                                   const Rect& text_bounds,
-                                   int line_height,
-                                   int flags,
-                                   const ShadowValues& shadows) {
+void Canvas::DrawStringWithShadowsRect(const base::string16& text,
+                                       const FontList& font_list,
+                                       SkColor color,
+                                       const Rect& text_bounds,
+                                       int line_height,
+                                       int flags,
+                                       const ShadowValues& shadows) {
   if (!IntersectsClipRect(text_bounds))
     return;
 
   flags = AdjustPlatformSpecificFlags(text, flags);
 
   Rect clip_rect(text_bounds);
   clip_rect.Inset(ShadowValue::GetMargin(shadows));
 
   canvas_->save(SkCanvas::kClip_SaveFlag);
   ClipRect(clip_rect);
@@ skipping 10 matching lines @@
 
   if (flags & MULTI_LINE) {
     ui::WordWrapBehavior wrap_behavior = ui::IGNORE_LONG_WORDS;
     if (flags & CHARACTER_BREAK)
       wrap_behavior = ui::WRAP_LONG_WORDS;
     else if (!(flags & NO_ELLIPSIS))
       wrap_behavior = ui::ELIDE_LONG_WORDS;
 
     std::vector<base::string16> strings;
     ui::ElideRectangleText(adjusted_text,
-                           font,
+                           font_list,
                            text_bounds.width(), text_bounds.height(),
                            wrap_behavior,
                            &strings);
 
     for (size_t i = 0; i < strings.size(); i++) {
       ui::Range range = StripAcceleratorChars(flags, &strings[i]);
-      UpdateRenderText(rect, strings[i], font, flags, color, render_text.get());
+      UpdateRenderText(rect, strings[i], font_list, flags, color,
+                       render_text.get());
       int line_padding = 0;
       if (line_height > 0)
         line_padding = line_height - render_text->GetStringSize().height();
       else
         line_height = render_text->GetStringSize().height();
 
       // TODO(msw|asvitkine): Center Windows multi-line text: crbug.com/107357
 #if !defined(OS_WIN)
       if (i == 0) {
         // TODO(msw|asvitkine): Support multi-line text with varied heights.
@@ skipping 20 matching lines @@
     if (elide_text) {
       render_text->SetText(adjusted_text);
       if (render_text->GetTextDirection() == base::i18n::LEFT_TO_RIGHT) {
         render_text->set_fade_tail(true);
         elide_text = false;
       }
     }
 #endif
 
     if (elide_text) {
-      ElideTextAndAdjustRange(font,
+      ElideTextAndAdjustRange(font_list,
                               text_bounds.width(),
                               &adjusted_text,
                               &range);
     }
 
-    UpdateRenderText(rect, adjusted_text, font, flags, color,
+    UpdateRenderText(rect, adjusted_text, font_list, flags, color,
                      render_text.get());
 
     const int text_height = render_text->GetStringSize().height();
     // Center the text vertically.
     rect += Vector2d(0, (text_bounds.height() - text_height) / 2);
     rect.set_height(text_height);
     render_text->SetDisplayRect(rect);
     if (range.IsValid())
       render_text->ApplyStyle(UNDERLINE, true, range);
     render_text->Draw(this);
   }
 
   canvas_->restore();
 }
 
-void Canvas::DrawStringWithHalo(const base::string16& text,
-                                const Font& font,
-                                SkColor text_color,
-                                SkColor halo_color_in,
-                                int x, int y, int w, int h,
-                                int flags) {
+void Canvas::DrawStringWithHaloRect(const base::string16& text,
+                                    const FontList& font_list,
+                                    SkColor text_color,
+                                    SkColor halo_color_in,
+                                    const Rect& display_rect,
+                                    int flags) {
   // Some callers will have semitransparent halo colors, which we don't handle
   // (since the resulting image can have 1-bit transparency only).
   SkColor halo_color = SkColorSetA(halo_color_in, 0xFF);
 
   // Create a temporary buffer filled with the halo color. It must leave room
   // for the 1-pixel border around the text.
-  Size size(w + 2, h + 2);
+  Size size(display_rect.width() + 2, display_rect.height() + 2);
   Canvas text_canvas(size, scale_factor(), true);
   SkPaint bkgnd_paint;
   bkgnd_paint.setColor(halo_color);
   text_canvas.DrawRect(Rect(size), bkgnd_paint);
 
   // Draw the text into the temporary buffer. This will have correct
   // ClearType since the background color is the same as the halo color.
-  text_canvas.DrawStringInt(text, font, text_color, 1, 1, w, h, flags);
+  text_canvas.DrawStringWithFlagsRect(
+      text, font_list, text_color,
+      Rect(1, 1, display_rect.width(), display_rect.height()), flags);
 
   uint32_t halo_premul = SkPreMultiplyColor(halo_color);
   SkBitmap& text_bitmap = const_cast<SkBitmap&>(
       skia::GetTopDevice(*text_canvas.sk_canvas())->accessBitmap(true));
 
   for (int cur_y = 0; cur_y < text_bitmap.height(); cur_y++) {
     uint32_t* text_row = text_bitmap.getAddr32(0, cur_y);
     for (int cur_x = 0; cur_x < text_bitmap.width(); cur_x++) {
       if (text_row[cur_x] == halo_premul) {
         // This pixel was not touched by the text routines. See if it borders
         // a touched pixel in any of the 4 directions (not diagonally).
         if (!PixelShouldGetHalo(text_bitmap, cur_x, cur_y, halo_premul))
           text_row[cur_x] = 0;  // Make transparent.
       } else {
         text_row[cur_x] |= 0xff << SK_A32_SHIFT;  // Make opaque.
       }
     }
   }
 
   // Draw the halo bitmap with blur.
   ImageSkia text_image = ImageSkia(ImageSkiaRep(text_bitmap,
       text_canvas.scale_factor()));
-  DrawImageInt(text_image, x - 1, y - 1);
+  DrawImageInt(text_image, display_rect.x() - 1, display_rect.y() - 1);
 }
 
-void Canvas::DrawFadeTruncatingString(
-      const base::string16& text,
-      TruncateFadeMode truncate_mode,
-      size_t desired_characters_to_truncate_from_head,
-      const Font& font,
-      SkColor color,
-      const Rect& display_rect) {
+void Canvas::DrawFadeTruncatingStringRect(
+    const base::string16& text,
+    TruncateFadeMode truncate_mode,
+    size_t desired_characters_to_truncate_from_head,
+    const FontList& font_list,
+    SkColor color,
+    const Rect& display_rect) {
   int flags = NO_ELLIPSIS;
 
   // If the whole string fits in the destination then just draw it directly.
-  if (GetStringWidth(text, font) <= display_rect.width()) {
-    DrawStringInt(text, font, color, display_rect.x(), display_rect.y(),
-                  display_rect.width(), display_rect.height(), flags);
+  if (GetStringWidth(text, font_list) <= display_rect.width()) {
+    DrawStringWithFlagsRect(text, font_list, color, display_rect, flags);
     return;
   }
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   base::string16 clipped_text = text;
   const bool is_rtl = AdjustStringDirection(flags, &clipped_text);
 
   switch (truncate_mode) {
     case TruncateFadeTail:
       render_text->set_fade_tail(true);
@@ skipping 25 matching lines @@
       render_text->set_fade_tail(true);
       render_text->set_fade_head(true);
       break;
   }
 
   // Default to left alignment unless right alignment was chosen above.
   if (!(flags & TEXT_ALIGN_RIGHT))
     flags |= TEXT_ALIGN_LEFT;
 
   Rect rect = display_rect;
-  UpdateRenderText(rect, clipped_text, font, flags, color, render_text.get());
+  UpdateRenderText(rect, clipped_text, font_list, flags, color,
+                   render_text.get());
 
   const int line_height = render_text->GetStringSize().height();
   // Center the text vertically.
   rect += Vector2d(0, (display_rect.height() - line_height) / 2);
   rect.set_height(line_height);
   render_text->SetDisplayRect(rect);
 
   canvas_->save(SkCanvas::kClip_SaveFlag);
   ClipRect(display_rect);
   render_text->Draw(this);
   canvas_->restore();
 }
 
 }  // namespace gfx