Allow various font weights in gfx.

ui/gfx/render_text_harfbuzz.cc

 // Copyright 2014 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_harfbuzz.h"
 
 #include <limits>
 #include <set>
 
 #include "base/i18n/bidi_line_iterator.h"
@@ skipping 558 matching lines @@
 TextRunHarfBuzz::TextRunHarfBuzz()
     : width(0.0f),
       preceding_run_widths(0.0f),
       is_rtl(false),
       level(0),
       script(USCRIPT_INVALID_CODE),
       glyph_count(static_cast<size_t>(-1)),
       font_size(0),
       baseline_offset(0),
       baseline_type(0),
-      font_style(0),
+      italic(false),
+      weight(gfx::Font::Weight::NORMAL),
       strike(false),
       diagonal_strike(false),
-      underline(false) {
-}
+      underline(false) {}
 
 TextRunHarfBuzz::~TextRunHarfBuzz() {}
 
 Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const {
   DCHECK(range.Contains(char_range));
   DCHECK(!char_range.is_reversed());
   DCHECK(!char_range.is_empty());
 
   Range start_glyphs;
   Range end_glyphs;
@@ skipping 659 matching lines @@
   // Temporarily apply composition underlines and selection colors.
   ApplyCompositionAndSelectionStyles();
 
   // Build the run list from the script items and ranged styles and baselines.
   // Use an empty color BreakList to avoid breaking runs at color boundaries.
   BreakList<SkColor> empty_colors;
   empty_colors.SetMax(text.length());
   DCHECK_LE(text.size(), baselines().max());
   for (const BreakList<bool>& style : styles())
     DCHECK_LE(text.size(), style.max());
-  internal::StyleIterator style(empty_colors, baselines(), styles());
+  internal::StyleIterator style(empty_colors, baselines(), weights(), styles());
 
   for (size_t run_break = 0; run_break < text.length();) {
     internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz;
     run->range.set_start(run_break);
-    run->font_style = (style.style(BOLD) ? Font::BOLD : 0) |
-                      (style.style(ITALIC) ? Font::ITALIC : 0);
+    run->italic = style.style(ITALIC);
     run->baseline_type = style.baseline();
     run->strike = style.style(STRIKE);
     run->diagonal_strike = style.style(DIAGONAL_STRIKE);
     run->underline = style.style(UNDERLINE);
+    run->weight = style.weight();
     int32_t script_item_break = 0;
     bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level);
     CHECK_GT(static_cast<size_t>(script_item_break), run_break);
     // Odd BiDi embedding levels correspond to RTL runs.
     run->is_rtl = (run->level % 2) == 1;
     // Find the length and script of this script run.
     script_item_break = ScriptInterval(text, run_break,
         script_item_break - run_break, &run->script) + run_break;
 
     // Find the next break and advance the iterators as needed.
@@ skipping 144 matching lines @@
       continue;
 #endif
     if (fallback_fonts.find(font) != fallback_fonts.end())
       continue;
 
     fallback_fonts.insert(font);
 
     FontRenderParamsQuery query;
     query.families.push_back(font_name);
     query.pixel_size = run->font_size;
-    query.style = run->font_style;
+    query.style = run->italic ? gfx::Font::ITALIC : 0;
     FontRenderParams fallback_render_params = GetFontRenderParams(query, NULL);
     if (CompareFamily(text, font, fallback_render_params, run, &best_font,
                       &best_render_params, &best_missing_glyphs))
       return;
   }
 
   if (best_missing_glyphs != std::numeric_limits<size_t>::max() &&
       (best_font.GetFontName() == run->font.GetFontName() ||
        ShapeRunWithFont(text, best_font, best_render_params, run)))
     return;
 
   run->glyph_count = 0;
   run->width = 0.0f;
 }
 
 bool RenderTextHarfBuzz::ShapeRunWithFont(const base::string16& text,
                                           const gfx::Font& font,
                                           const FontRenderParams& params,
                                           internal::TextRunHarfBuzz* run) {
   skia::RefPtr<SkTypeface> skia_face =
-      internal::CreateSkiaTypeface(font, run->font_style);
+      internal::CreateSkiaTypeface(font, run->italic, run->weight);
   if (skia_face == NULL)
     return false;
   run->skia_face = skia_face;
   run->font = font;
   run->render_params = params;
 
   hb_font_t* harfbuzz_font = CreateHarfBuzzFont(
       run->skia_face.get(), SkIntToScalar(run->font_size), run->render_params,
       subpixel_rendering_suppressed());
 
@@ skipping 97 matching lines @@
   DCHECK(!update_layout_run_list_);
   DCHECK(!update_display_run_list_);
   return text_elided() ? display_run_list_.get() : &layout_run_list_;
 }
 
 const internal::TextRunList* RenderTextHarfBuzz::GetRunList() const {
   return const_cast<RenderTextHarfBuzz*>(this)->GetRunList();
 }
 
 }  // namespace gfx