Allow various font weights in gfx.

ui/gfx/platform_font_mac.mm

 // 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/platform_font_mac.h"
 
 #include <cmath>
 
 #include <Cocoa/Cocoa.h>
 
@@ skipping 47 matching lines @@
 // PlatformFontMac, public:
 
 PlatformFontMac::PlatformFontMac()
     : PlatformFontMac([NSFont systemFontOfSize:[NSFont systemFontSize]]) {
 }
 
 PlatformFontMac::PlatformFontMac(NativeFont native_font)
     : native_font_([native_font retain]),
       font_name_(base::SysNSStringToUTF8([native_font_ familyName])),
       font_size_([native_font_ pointSize]),
-      font_style_(Font::NORMAL) {
+      font_style_(Font::NORMAL),
+      font_weight_(Font::Weight::NORMAL) {
   NSFontSymbolicTraits traits = [[native_font fontDescriptor] symbolicTraits];

[tapted, 2016/03/23 23:00:06]

Without a BUG= I can't grok the wider plan for this change, but NSFont does have
other weights. You can get them with something like

NSNumber* weight =
    [[native_font fontDescriptor] fontAttibutes][NSFontWeightTrait];

The value will be a floating point number between -1.0 and 1.0.

Is there a plan to add this? The CL is already big and you'll need Mac
reviewers, so perhaps file a new bug, and reference it here with a TODO

[Mikus, 2016/03/24 07:31:25]

Done.

[msw, 2016/03/25 01:41:31]

Please cite the bug you filed in the BUG= line of the CL description.
I'm not entirely sure, but I think Trent was actually asking for a broader bug
describing the need for this change (even if it's just *needed* downstream for
now), a description of its benefits/effects (like enabling Chrome to respect
users' system font weights; neat!), and bigger TODOs (like *actually* respecting
users' system font weights). Either way, please file a bug like that (or broaden
the Mac one), and list it in BUG=; thanks!

[tapted, 2016/03/27 23:10:01]

The bug still doesn't describe the _need_ for the change. You've set me as the
owner, and you're leaving the mac implementation incomplete. Describing the need
for the change allows us to determine what priority to attach to the remaining
parts, and find appropriate owners.

   if (traits & NSFontItalicTrait)
     font_style_ |= Font::ITALIC;
   if (traits & NSFontBoldTrait)
-    font_style_ |= Font::BOLD;
+    font_weight_ = Font::BOLD;

[tapted, 2016/03/23 23:00:06]

Font::Weight::BOLD? - what you have shouldn't compile

[Mikus, 2016/03/24 07:31:25]

Done.

+  else
+    font_weight_ = Font::NORMAL;
 
   CalculateMetricsAndInitRenderParams();
 }
 
-PlatformFontMac::PlatformFontMac(const std::string& font_name,
-                                 int font_size)
+PlatformFontMac::PlatformFontMac(const std::string& font_name, int font_size)
     : native_font_([NSFontWithSpec(font_name, font_size, Font::NORMAL) retain]),
       font_name_(font_name),
       font_size_(font_size),
-      font_style_(Font::NORMAL) {
+      font_style_(Font::NORMAL),
+      font_weight_(Font::Weight::NORMAL) {
   CalculateMetricsAndInitRenderParams();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontMac, PlatformFont implementation:
 
-Font PlatformFontMac::DeriveFont(int size_delta, int style) const {
-  if (native_font_ && style == font_style_) {
+Font PlatformFontMac::DeriveFont(int size_delta,
+                                 int style,
+                                 Font::Weight weight) const {
+  if (native_font_ && style == font_style_ && weight == font_weight_) {
     // System fonts have special attributes starting with 10.11. They should be
     // requested using the same descriptor to preserve these attributes.
-    return Font(new PlatformFontMac(
-        [NSFont fontWithDescriptor:[native_font_ fontDescriptor]
-                              size:font_size_ + size_delta]));
+    return Font(new PlatformFontMac([NSFont
+        fontWithDescriptor:[native_font_ fontDescriptor]
+                      size:font_size_ + size_delta]));
   }
 
-  return Font(new PlatformFontMac(font_name_, font_size_ + size_delta, style));
+  return Font(
+      new PlatformFontMac(font_name_, font_size_ + size_delta, style, weight));
 }
 
 int PlatformFontMac::GetHeight() {
   return height_;
 }
 
 int PlatformFontMac::GetBaseline() {
   return ascent_;
 }
 
 int PlatformFontMac::GetCapHeight() {
   return cap_height_;
 }
 
 int PlatformFontMac::GetExpectedTextWidth(int length) {
   return length * average_width_;
 }
 
 int PlatformFontMac::GetStyle() const {
   return font_style_;
 }
 
+Font::Weight PlatformFontMac::GetWeight() const {
+  return font_weight_;
+}
+
 const std::string& PlatformFontMac::GetFontName() const {
   return font_name_;
 }
 
 std::string PlatformFontMac::GetActualFontNameForTesting() const {
   return base::SysNSStringToUTF8([native_font_ familyName]);
 }
 
 int PlatformFontMac::GetFontSize() const {
   return font_size_;
 }
 
 const FontRenderParams& PlatformFontMac::GetFontRenderParams() {
   return render_params_;
 }
 
 NativeFont PlatformFontMac::GetNativeFont() const {
   return [[native_font_.get() retain] autorelease];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontMac, private:
 
 PlatformFontMac::PlatformFontMac(const std::string& font_name,
                                  int font_size,
-                                 int font_style)
+                                 int font_style,
+                                 Font::Weight font_weight)
     : native_font_([NSFontWithSpec(font_name, font_size, font_style) retain]),
       font_name_(font_name),
       font_size_(font_size),
-      font_style_(font_style) {
+      font_style_(font_style),
+      font_weight_(font_weight) {
   CalculateMetricsAndInitRenderParams();
 }
 
 PlatformFontMac::~PlatformFontMac() {
 }
 
 void PlatformFontMac::CalculateMetricsAndInitRenderParams() {
   NSFont* font = native_font_.get();
   if (!font) {
     // This object was constructed from a font name that doesn't correspond to
@@ skipping 17 matching lines @@
   // to ensure GetBaseline() + descender fits within GetHeight() during layout.
   height_ = ceil(ascent_ + std::abs([font descender]) + [font leading]);
 
   average_width_ =
       NSWidth([font boundingRectForGlyph:[font glyphWithName:@"x"]]);
 
   FontRenderParamsQuery query;
   query.families.push_back(font_name_);
   query.pixel_size = font_size_;
   query.style = font_style_;
+  query.weight = font_weight_;
   render_params_ = gfx::GetFontRenderParams(query, NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFont, public:
 
 // static
 PlatformFont* PlatformFont::CreateDefault() {
   return new PlatformFontMac;
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNativeFont(NativeFont native_font) {
   return new PlatformFontMac(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontMac(font_name, font_size);
 }
 
 }  // namespace gfx