Allow various font weights in gfx.

ui/gfx/font_list.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/font_list.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 11 matching lines @@
 bool g_default_impl_initialized = false;
 
 }  // namespace
 
 namespace gfx {
 
 // static
 bool FontList::ParseDescription(const std::string& description,
                                 std::vector<std::string>* families_out,
                                 int* style_out,
-                                int* size_pixels_out) {
+                                int* size_pixels_out,
+                                gfx::Font::FontWeight* weight_out) {
   DCHECK(families_out);
   DCHECK(style_out);
   DCHECK(size_pixels_out);
+  DCHECK(weight_out);
 
   *families_out = base::SplitString(
       description, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (families_out->empty())
     return false;
   for (auto& family : *families_out)
     base::TrimWhitespaceASCII(family, base::TRIM_ALL, &family);
 
   // The last item is "[STYLE1] [STYLE2] [...] SIZE".
   std::vector<std::string> styles = base::SplitString(
       families_out->back(), base::kWhitespaceASCII,
       base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   families_out->pop_back();
   if (styles.empty())
     return false;
 
   // The size takes the form "<INT>px".
   std::string size_string = styles.back();
   styles.pop_back();
   if (!base::EndsWith(size_string, "px", base::CompareCase::SENSITIVE))
     return false;
   size_string.resize(size_string.size() - 2);
   if (!base::StringToInt(size_string, size_pixels_out) ||
       *size_pixels_out <= 0)
     return false;
 
-  // Font supports BOLD and ITALIC; underline is supported via RenderText.
+  // Font supports ITALIC; underline is supported via RenderText.

[msw, 2016/03/22 01:53:43]

nit: "ITALIC and weights"

[Mikus, 2016/03/22 14:19:51]

Done.

   *style_out = gfx::Font::NORMAL;
+  *weight_out = gfx::Font::WEIGHT_NORMAL;
   for (const auto& style_string : styles) {
-    if (style_string == "Bold")
-      *style_out |= gfx::Font::BOLD;
-    else if (style_string == "Italic")
+    if (style_string == "Italic")
       *style_out |= gfx::Font::ITALIC;
+    else if (style_string == "Thin")
+      *weight_out = gfx::Font::WEIGHT_THIN;
+    else if (style_string == "Ultra-Light")
+      *weight_out = gfx::Font::WEIGHT_EXTRA_LIGHT;
+    else if (style_string == "Light")
+      *weight_out = gfx::Font::WEIGHT_LIGHT;
+    else if (style_string == "Normal")
+      *weight_out = gfx::Font::WEIGHT_NORMAL;
+    else if (style_string == "Medium")
+      *weight_out = gfx::Font::WEIGHT_MEDIUM;
+    else if (style_string == "Semi-Bold")
+      *weight_out = gfx::Font::WEIGHT_SEMIBOLD;
+    else if (style_string == "Bold")
+      *weight_out = gfx::Font::WEIGHT_BOLD;
+    else if (style_string == "Ultra-Bold")
+      *weight_out = gfx::Font::WEIGHT_EXTRA_BOLD;
+    else if (style_string == "Heavy")
+      *weight_out = gfx::Font::WEIGHT_BLACK;
     else
       return false;
   }
 
   return true;
 }
 
 FontList::FontList() : impl_(GetDefaultImpl()) {}
 
 FontList::FontList(const FontList& other) : impl_(other.impl_) {}
 
 FontList::FontList(const std::string& font_description_string)
     : impl_(new FontListImpl(font_description_string)) {}
 
 FontList::FontList(const std::vector<std::string>& font_names,
                    int font_style,
-                   int font_size)
-    : impl_(new FontListImpl(font_names, font_style, font_size)) {}
+                   int font_size,
+                   int font_weight)
+    : impl_(new FontListImpl(font_names, font_style, font_size, font_weight)) {}
 
 FontList::FontList(const std::vector<Font>& fonts)
     : impl_(new FontListImpl(fonts)) {}
 
 FontList::FontList(const Font& font) : impl_(new FontListImpl(font)) {}
 
 FontList::~FontList() {}
 
 FontList& FontList::operator=(const FontList& other) {
   impl_ = other.impl_;
   return *this;
 }
 
 // static
 void FontList::SetDefaultFontDescription(const std::string& font_description) {
   // The description string must end with "px" for size in pixel, or must be
   // the empty string, which specifies to use a single default font.
   DCHECK(font_description.empty() ||
          base::EndsWith(font_description, "px", base::CompareCase::SENSITIVE));
 
   g_default_font_description.Get() = font_description;
   g_default_impl_initialized = false;
 }
 
-FontList FontList::Derive(int size_delta, int font_style) const {
-  return FontList(impl_->Derive(size_delta, font_style));
+FontList FontList::Derive(int size_delta,
+                          int font_style,
+                          gfx::Font::FontWeight weight) const {
+  return FontList(impl_->Derive(size_delta, font_style, weight));
 }
 
 FontList FontList::DeriveWithSizeDelta(int size_delta) const {
-  return Derive(size_delta, GetFontStyle());
+  return Derive(size_delta, GetFontStyle(), GetFontWeight());
 }
 
 FontList FontList::DeriveWithStyle(int font_style) const {
-  return Derive(0, font_style);
+  return Derive(0, font_style, GetFontWeight());
+}
+
+FontList FontList::DeriveWithWeight(gfx::Font::FontWeight weight) const {
+  return Derive(0, GetFontStyle(), weight);
 }
 
 gfx::FontList FontList::DeriveWithHeightUpperBound(int height) const {
   gfx::FontList font_list(*this);
   for (int font_size = font_list.GetFontSize(); font_size > 1; --font_size) {
     const int internal_leading =
         font_list.GetBaseline() - font_list.GetCapHeight();
     // 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
@@ skipping 27 matching lines @@
 }
 
 int FontList::GetFontStyle() const {
   return impl_->GetFontStyle();
 }
 
 int FontList::GetFontSize() const {
   return impl_->GetFontSize();
 }
 
+gfx::Font::FontWeight FontList::GetFontWeight() const {
+  return impl_->GetFontWeight();
+}
+
 const std::vector<Font>& FontList::GetFonts() const {
   return impl_->GetFonts();
 }
 
 const Font& FontList::GetPrimaryFont() const {
   return impl_->GetPrimaryFont();
 }
 
 FontList::FontList(FontListImpl* impl) : impl_(impl) {}
 
 // static
 const scoped_refptr<FontListImpl>& FontList::GetDefaultImpl() {
   // SetDefaultFontDescription() must be called and the default font description
   // must be set earlier than any call of this function.
   DCHECK(!(g_default_font_description == NULL))  // != is not overloaded.
       << "SetDefaultFontDescription has not been called.";
 
   if (!g_default_impl_initialized) {
     g_default_impl.Get() =
         g_default_font_description.Get().empty() ?
             new FontListImpl(Font()) :
             new FontListImpl(g_default_font_description.Get());
     g_default_impl_initialized = true;
   }
 
   return g_default_impl.Get();
 }
 
 }  // namespace gfx