Allow various font weights in gfx.

ui/gfx/render_text.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/render_text.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <climits>
 
 #include "base/command_line.h"
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "third_party/icu/source/common/unicode/rbbi.h"
 #include "third_party/icu/source/common/unicode/utf16.h"
 #include "third_party/skia/include/core/SkDrawLooper.h"
+#include "third_party/skia/include/core/SkFontStyle.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/platform_font.h"
 #include "ui/gfx/render_text_harfbuzz.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/switches.h"
@@ skipping 50 matching lines @@
   // Some platforms don't support getting the cap height, and simply return
   // the entire font ascent from GetCapHeight().  Centering the ascent makes
   // the font look too low, so if GetCapHeight() returns the ascent, center
   // the entire font height instead.
   const int space =
       display_height - ((internal_leading != 0) ? cap_height : font_height);
   const int baseline_shift = space / 2 - internal_leading;
   return baseline + std::max(min_shift, std::min(max_shift, baseline_shift));
 }
 
-#if !defined(OS_MACOSX)
-// Converts |Font::FontStyle| flags to |SkTypeface::Style| flags.
-SkTypeface::Style ConvertFontStyleToSkiaTypefaceStyle(int font_style) {
-  int skia_style = SkTypeface::kNormal;
-  skia_style |= (font_style & Font::BOLD) ? SkTypeface::kBold : 0;
-  skia_style |= (font_style & Font::ITALIC) ? SkTypeface::kItalic : 0;
-  return static_cast<SkTypeface::Style>(skia_style);
-}
-#endif
-
 int round(float value) {
   return static_cast<int>(floor(value + 0.5f));
 }
 
 // Given |font| and |display_width|, returns the width of the fade gradient.
 int CalculateFadeGradientWidth(const FontList& font_list, int display_width) {
   // Fade in/out about 3 characters of the beginning/end of the string.
   // Use a 1/3 of the display width if the display width is very short.
   const int narrow_width = font_list.GetExpectedTextWidth(3);
   const int gradient_width = std::min(narrow_width, round(display_width / 3.f));
@@ skipping 133 matching lines @@
 }
 
 void SkiaTextRenderer::SetTypeface(SkTypeface* typeface) {
   paint_.setTypeface(typeface);
 }
 
 void SkiaTextRenderer::SetTextSize(SkScalar size) {
   paint_.setTextSize(size);
 }
 
-void SkiaTextRenderer::SetFontWithStyle(const Font& font, int style) {
-  skia::RefPtr<SkTypeface> typeface = CreateSkiaTypeface(font, style);
+void SkiaTextRenderer::SetFont(const Font& font,
+                               bool italic,
+                               gfx::Font::Weight weight) {
+  skia::RefPtr<SkTypeface> typeface = CreateSkiaTypeface(font, italic, weight);
   if (typeface) {
     // |paint_| adds its own ref. So don't |release()| it from the ref ptr here.
     SetTypeface(typeface.get());
 
     // Enable fake bold text if bold style is needed but new typeface does not
     // have it.
-    paint_.setFakeBoldText((style & Font::BOLD) && !typeface->isBold());
+    paint_.setFakeBoldText(weight >= gfx::Font::Weight::SEMIBOLD &&
+                           !typeface->isBold());
   }
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
   paint_.setColor(foreground);
 }
 
 void SkiaTextRenderer::SetShader(SkShader* shader) {
   paint_.setShader(shader);
 }
@@ skipping 102 matching lines @@
 
     if (clipped)
       canvas_->Restore();
 
     x += pieces_[i].first;
   }
 }
 
 StyleIterator::StyleIterator(const BreakList<SkColor>& colors,
                              const BreakList<BaselineStyle>& baselines,
+                             const BreakList<gfx::Font::Weight>& weights,
                              const std::vector<BreakList<bool>>& styles)
-    : colors_(colors), baselines_(baselines), styles_(styles) {
+    : colors_(colors),
+      baselines_(baselines),
+      weights_(weights),
+      styles_(styles) {
   color_ = colors_.breaks().begin();
   baseline_ = baselines_.breaks().begin();
+  weight_ = weights_.breaks().begin();
   for (size_t i = 0; i < styles_.size(); ++i)
     style_.push_back(styles_[i].breaks().begin());
 }
 
 StyleIterator::~StyleIterator() {}
 
 Range StyleIterator::GetRange() const {
   Range range(colors_.GetRange(color_));
   range = range.Intersect(baselines_.GetRange(baseline_));
+  range = range.Intersect(weights_.GetRange(weight_));
   for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
     range = range.Intersect(styles_[i].GetRange(style_[i]));
   return range;
 }
 
 void StyleIterator::UpdatePosition(size_t position) {
   color_ = colors_.GetBreak(position);
   baseline_ = baselines_.GetBreak(position);
+  weight_ = weights_.GetBreak(position);
   for (size_t i = 0; i < NUM_TEXT_STYLES; ++i)
     style_[i] = styles_[i].GetBreak(position);
 }
 
 LineSegment::LineSegment() : run(0) {}
 
 LineSegment::~LineSegment() {}
 
 Line::Line() : preceding_heights(0), baseline(0) {}
 
 Line::Line(const Line& other) = default;
 
 Line::~Line() {}
 
 #if !defined(OS_MACOSX)
-skia::RefPtr<SkTypeface> CreateSkiaTypeface(const gfx::Font& font, int style) {
-  SkTypeface::Style skia_style = ConvertFontStyleToSkiaTypefaceStyle(style);
+skia::RefPtr<SkTypeface> CreateSkiaTypeface(const gfx::Font& font,
+                                            bool italic,
+                                            gfx::Font::Weight weight) {
+  SkFontStyle skia_style(
+      static_cast<int>(weight), SkFontStyle::kNormal_Width,
+      italic ? SkFontStyle::kItalic_Slant : SkFontStyle::kUpright_Slant);
   return skia::AdoptRef(
       SkTypeface::CreateFromName(font.GetFontName().c_str(), skia_style));
 }
+

[msw, 2016/03/22 18:24:11]

nit: remove blank line

[Mikus, 2016/03/23 17:53:22]

Done.

 #endif
 
 void ApplyRenderParams(const FontRenderParams& params,
                        bool subpixel_rendering_suppressed,
                        SkPaint* paint) {
   paint->setAntiAlias(params.antialiasing);
   paint->setLCDRenderText(!subpixel_rendering_suppressed &&
       params.subpixel_rendering != FontRenderParams::SUBPIXEL_RENDERING_NONE);
   paint->setSubpixelText(params.subpixel_positioning);
   paint->setAutohinted(params.autohinter);
@@ skipping 26 matching lines @@
   DCHECK(!composition_range_.IsValid());
   if (text_ == text)
     return;
   text_ = text;
   UpdateStyleLengths();
 
   // Clear style ranges as they might break new text graphemes and apply
   // the first style to the whole text instead.
   colors_.SetValue(colors_.breaks().begin()->second);
   baselines_.SetValue(baselines_.breaks().begin()->second);
+  weights_.SetValue(weights_.breaks().begin()->second);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
     styles_[style].SetValue(styles_[style].breaks().begin()->second);
   cached_bounds_and_offset_valid_ = false;
 
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel());
 
   // Invalidate the cached text direction if it depends on the text contents.
   if (directionality_mode_ == DIRECTIONALITY_FROM_TEXT)
@@ skipping 15 matching lines @@
   if (horizontal_alignment_ != alignment) {
     horizontal_alignment_ = alignment;
     display_offset_ = Vector2d();
     cached_bounds_and_offset_valid_ = false;
   }
 }
 
 void RenderText::SetFontList(const FontList& font_list) {
   font_list_ = font_list;
   const int font_style = font_list.GetFontStyle();
-  SetStyle(BOLD, (font_style & gfx::Font::BOLD) != 0);
+  weights_.SetValue(font_list.GetFontWeight());
   SetStyle(ITALIC, (font_style & gfx::Font::ITALIC) != 0);

[msw, 2016/03/22 18:24:11]

Make these two SetStyle calls also assign directly (for performance):
  styles_[ITALIC].SetValue((font_style & gfx::Font::ITALIC) != 0);
  styles_[UNDERLINE].SetValue((font_style & gfx::Font::UNDERLINE) != 0);

[Mikus, 2016/03/23 17:53:22]

Done.

   SetStyle(UNDERLINE, (font_style & gfx::Font::UNDERLINE) != 0);
   baseline_ = kInvalidBaseline;
   cached_bounds_and_offset_valid_ = false;
   OnLayoutTextAttributeChanged(false);
 }
 
 void RenderText::SetCursorEnabled(bool cursor_enabled) {
   cursor_enabled_ = cursor_enabled;
   cached_bounds_and_offset_valid_ = false;
 }
@@ skipping 240 matching lines @@
   const size_t end = IsValidCursorIndex(range.end()) ? range.end() :
       IndexOfAdjacentGrapheme(range.end(), CURSOR_FORWARD);
   styles_[style].ApplyValue(value, Range(start, end));
 
   cached_bounds_and_offset_valid_ = false;
   // TODO(oshima|msw): Not all style change requires layout changes.
   // Consider optimizing based on the type of change.
   OnLayoutTextAttributeChanged(false);
 }
 
+void RenderText::SetWeight(gfx::Font::Weight weight) {
+  weights_.SetValue(weight);
+
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
+void RenderText::ApplyWeight(gfx::Font::Weight weight, const Range& range) {
+  weights_.ApplyValue(weight, range);
+
+  cached_bounds_and_offset_valid_ = false;
+  OnLayoutTextAttributeChanged(false);
+}
+
 bool RenderText::GetStyle(TextStyle style) const {
   return (styles_[style].breaks().size() == 1) &&
       styles_[style].breaks().front().second;
 }
 
 void RenderText::SetDirectionalityMode(DirectionalityMode mode) {
   if (mode == directionality_mode_)
     return;
 
   directionality_mode_ = mode;
@@ skipping 211 matching lines @@
       cursor_enabled_(true),
       cursor_visible_(false),
       insert_mode_(true),
       cursor_color_(kDefaultColor),
       selection_color_(kDefaultColor),
       selection_background_focused_color_(kDefaultSelectionBackgroundColor),
       focused_(false),
       composition_range_(Range::InvalidRange()),
       colors_(kDefaultColor),
       baselines_(NORMAL_BASELINE),
+      weights_(gfx::Font::Weight::NORMAL),
       styles_(NUM_TEXT_STYLES),
       composition_and_selection_styles_applied_(false),
       obscured_(false),
       obscured_reveal_index_(-1),
       truncate_length_(0),
       elide_behavior_(NO_ELIDE),
       text_elided_(false),
       min_line_height_(0),
       multiline_(false),
       word_wrap_behavior_(IGNORE_LONG_WORDS),
       replace_newline_chars_with_symbols_(true),
       subpixel_rendering_suppressed_(false),
       clip_to_display_rect_(true),
       baseline_(kInvalidBaseline),
-      cached_bounds_and_offset_valid_(false) {
-}
+      cached_bounds_and_offset_valid_(false) {}
 
 SelectionModel RenderText::GetAdjacentSelectionModel(
     const SelectionModel& current,
     BreakType break_type,
     VisualCursorDirection direction) {
   EnsureLayout();
 
   if (break_type == LINE_BREAK || text().empty())
     return EdgeSelectionModel(direction);
   if (break_type == CHARACTER_BREAK)
@@ skipping 250 matching lines @@
   ptrdiff_t i = obscured() ? UTF16IndexToOffset(text(), 0, index) : index;
   CHECK_GE(i, 0);
   // Clamp indices to the length of the given layout or display text.
   return std::min<size_t>(given_text.length(), i);
 }
 
 void RenderText::UpdateStyleLengths() {
   const size_t text_length = text_.length();
   colors_.SetMax(text_length);
   baselines_.SetMax(text_length);
+  weights_.SetMax(text_length);
   for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
     styles_[style].SetMax(text_length);
 }
 
 // static
 bool RenderText::RangeContainsCaret(const Range& range,
                                     size_t caret_pos,
                                     LogicalCursorDirection caret_affinity) {
   // NB: exploits unsigned wraparound (WG14/N1124 section 6.2.5 paragraph 9).
   size_t adjacent = (caret_affinity == CURSOR_BACKWARD) ?
@@ skipping 83 matching lines @@
 
   // Create a RenderText copy with attributes that affect the rendering width.
   scoped_ptr<RenderText> render_text = CreateInstanceOfSameType();
   render_text->SetFontList(font_list_);
   render_text->SetDirectionalityMode(directionality_mode_);
   render_text->SetCursorEnabled(cursor_enabled_);
   render_text->set_truncate_length(truncate_length_);
   render_text->styles_ = styles_;
   render_text->baselines_ = baselines_;
   render_text->colors_ = colors_;
+  render_text->weights_ = weights_;
   if (text_width == 0) {
     render_text->SetText(text);
     text_width = render_text->GetContentWidthF();
   }
   if (text_width <= available_width)
     return text;
 
   const base::string16 ellipsis = base::string16(kEllipsisUTF16);
   const bool insert_ellipsis = (behavior != TRUNCATE);
   const bool elide_in_middle = (behavior == ELIDE_MIDDLE);
@@ skipping 37 matching lines @@
           new_text += base::i18n::kRightToLeftMark;
       }
       render_text->SetText(new_text);
     }
 
     // Restore styles and baselines without breaking multi-character graphemes.
     render_text->styles_ = styles_;
     for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
       RestoreBreakList(render_text.get(), &render_text->styles_[style]);
     RestoreBreakList(render_text.get(), &render_text->baselines_);
+    RestoreBreakList(render_text.get(), &render_text->weights_);
 
     // We check the width of the whole desired string at once to ensure we
     // handle kerning/ligatures/etc. correctly.
     const float guess_width = render_text->GetContentWidthF();
     if (guess_width == available_width)
       break;
     if (guess_width > available_width) {
       hi = guess - 1;
       // Move back on the loop terminating condition when the guess is too wide.
       if (hi < lo)
@@ skipping 86 matching lines @@
 
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   for (const Rect& s : GetSubstringBounds(selection()))
     canvas->FillRect(s, selection_background_focused_color_);
 }
 
 }  // namespace gfx