Support finer grained font weights on Mac.

ui/gfx/platform_font_mac_unittest.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 <Cocoa/Cocoa.h>
 #include <stddef.h>
 
+#include "base/mac/mac_util.h"
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/font.h"
 
+// TODO(tapted): Remove gfx:: prefixes.
+namespace gfx {
+
 TEST(PlatformFontMacTest, DeriveFont) {
   // Use a base font that support all traits.
   gfx::Font base_font("Helvetica", 13);
 
   // Bold
   gfx::Font bold_font(
       base_font.Derive(0, gfx::Font::NORMAL, gfx::Font::Weight::BOLD));
   NSFontTraitMask traits = [[NSFontManager sharedFontManager]
       traitsOfFont:bold_font.GetNativeFont()];
   EXPECT_EQ(NSBoldFontMask, traits);
@@ skipping 31 matching lines @@
 
   int actual_style = gfx::Font::UNDERLINE;
   if (traits & NSFontItalicTrait)
     actual_style |= gfx::Font::ITALIC;
 
   EXPECT_TRUE(derived_font.GetStyle() & gfx::Font::UNDERLINE);
   EXPECT_EQ(derived_font.GetStyle(), actual_style);
   EXPECT_EQ(derived_font.GetWeight(), actual_weight);
 }
 
+// Tests internal methods for extracting gfx::Font properties from the
+// underlying CTFont representation.
 TEST(PlatformFontMacTest, ConstructFromNativeFont) {
-  gfx::Font normal_font([NSFont fontWithName:@"Helvetica" size:12]);
+  Font normal_font([NSFont fontWithName:@"Helvetica" size:12]);
   EXPECT_EQ(12, normal_font.GetFontSize());
   EXPECT_EQ("Helvetica", normal_font.GetFontName());
-  EXPECT_EQ(gfx::Font::NORMAL, normal_font.GetStyle());
-
-  gfx::Font bold_font([NSFont fontWithName:@"Helvetica-Bold" size:14]);
+  EXPECT_EQ(Font::NORMAL, normal_font.GetStyle());
+  EXPECT_EQ(Font::Weight::NORMAL, normal_font.GetWeight());
+
+  Font bold_font([NSFont fontWithName:@"Helvetica-Bold" size:14]);
   EXPECT_EQ(14, bold_font.GetFontSize());
   EXPECT_EQ("Helvetica", bold_font.GetFontName());
-  EXPECT_EQ(gfx::Font::Weight::BOLD, bold_font.GetWeight());
-
-  gfx::Font italic_font([NSFont fontWithName:@"Helvetica-Oblique" size:14]);
+  EXPECT_EQ(Font::NORMAL, bold_font.GetStyle());
+  EXPECT_EQ(Font::Weight::BOLD, bold_font.GetWeight());
+
+  Font italic_font([NSFont fontWithName:@"Helvetica-Oblique" size:14]);
   EXPECT_EQ(14, italic_font.GetFontSize());
   EXPECT_EQ("Helvetica", italic_font.GetFontName());
-  EXPECT_EQ(gfx::Font::ITALIC, italic_font.GetStyle());
-
-  gfx::Font bold_italic_font(
-      [NSFont fontWithName:@"Helvetica-BoldOblique" size:14]);
+  EXPECT_EQ(Font::ITALIC, italic_font.GetStyle());
+  EXPECT_EQ(Font::Weight::NORMAL, italic_font.GetWeight());
+
+  Font bold_italic_font([NSFont fontWithName:@"Helvetica-BoldOblique" size:14]);
   EXPECT_EQ(14, bold_italic_font.GetFontSize());
   EXPECT_EQ("Helvetica", bold_italic_font.GetFontName());
-  EXPECT_EQ(gfx::Font::ITALIC, bold_italic_font.GetStyle());
-  EXPECT_EQ(gfx::Font::Weight::BOLD, bold_italic_font.GetWeight());
+  EXPECT_EQ(Font::ITALIC, bold_italic_font.GetStyle());
+  EXPECT_EQ(Font::Weight::BOLD, bold_italic_font.GetWeight());
+}
+
+// Specific test for the mapping from the NSFont weight API to gfx::Font::Weight
+// values.
+TEST(PlatformFontMacTest, FontWeightAPIConsistency) {
+  // Vanilla Helvetica only has bold and normal, so use a system font.
+  NSFont* ns_font = [NSFont systemFontOfSize:13];
+  NSFontManager* manager = [NSFontManager sharedFontManager];
+
+  // -[NSFontManager convertWeight:ofFont] supposedly steps the font up and down
+  // in weight values according to a table at
+  // https://developer.apple.com/reference/appkit/nsfontmanager/1462321-convertweight
+  // Apple Terminology                 | ISO Equivalent
+  // 1. ultralight                     | none
+  // 2. thin                           | W1. ultralight
+  // 3. light, extralight              | W2. extralight
+  // 4. book                           | W3. light
+  // 5. regular, plain, display, roman | W4. semilight
+  // 6. medium                         | W5. medium
+  // 7. demi, demibold                 | none
+  // 8. semi, semibold                 | W6. semibold
+  // 9. bold                           | W7. bold
+  // 10. extra, extrabold              | W8. extrabold
+  // 11. heavy, heavyface              | none
+  // 12. black, super                  | W9. ultrabold
+  // 13. ultra, ultrablack, fat        | none
+  // 14. extrablack, obese, nord       | none
+  EXPECT_EQ(Font::Weight::NORMAL, Font(ns_font).GetWeight());  // Row 5.
+
+  // Ensure the Bold "symbolic" trait from the NSFont traits API maps correctly
+  // to the weight (non-symbolic) trait from the CTFont API.
+  NSFont* bold_ns_font =
+      [manager convertFont:ns_font toHaveTrait:NSFontBoldTrait];
+  Font bold_font(bold_ns_font);
+  EXPECT_EQ(Font::Weight::BOLD, bold_font.GetWeight());
+
+  // No thin fonts on the lower rows of the table for San Francisco or earlier
+  // system fonts.
+  BOOL down = NO;
+  ns_font = [NSFont systemFontOfSize:13];
+  for (int row = 4; row > 0; --row) {
+    SCOPED_TRACE(testing::Message() << "Row: " << row);
+    ns_font = [manager convertWeight:down ofFont:ns_font];
+    EXPECT_EQ(Font::Weight::NORMAL, Font(ns_font).GetWeight());
+  }
+
+  BOOL up = YES;
+  // That is... unless we first go up by one and then down. A LIGHT and a THIN
+  // font reveal themselves somehow. Only tested on 10.12.
+  if (base::mac::IsAtLeastOS10_12()) {
+    ns_font = [NSFont systemFontOfSize:13];
+    ns_font = [manager convertWeight:up ofFont:ns_font];
+    ns_font = [manager convertWeight:down ofFont:ns_font];
+    EXPECT_EQ(Font::Weight::LIGHT, Font(ns_font).GetWeight());
+    ns_font = [manager convertWeight:down ofFont:ns_font];
+    EXPECT_EQ(Font::Weight::THIN, Font(ns_font).GetWeight());
+  }
+
+  ns_font = [NSFont systemFontOfSize:13];
+  if (base::mac::IsOS10_9()) {
+    // On 10.9 the system font doesn't provide finer-grained weights. It's
+    // either bold or it isn't.
+    for (int row = 6; row <= 14; ++row) {
+      SCOPED_TRACE(testing::Message() << "Row: " << row);
+      ns_font = [manager convertWeight:up ofFont:ns_font];
+      EXPECT_EQ(Font::Weight::BOLD, Font(ns_font).GetWeight());
+    }
+    return;
+  }
+
+  if (base::mac::IsOS10_11()) {
+    // On 10.11 the API jumps to BOLD, but has heavier weights as well.
+    ns_font = [manager convertWeight:up ofFont:ns_font];
+    EXPECT_EQ(Font::Weight::BOLD, Font(ns_font).GetWeight());
+    ns_font = [manager convertWeight:up ofFont:ns_font];
+    EXPECT_EQ(Font::Weight::EXTRA_BOLD, Font(ns_font).GetWeight());
+    ns_font = [manager convertWeight:up ofFont:ns_font];
+    EXPECT_EQ(Font::Weight::BLACK, Font(ns_font).GetWeight());
+    return;
+  }
+
+  // Each typeface maps weight notches differently, and the weight is actually a
+  // floating point value that may not map directly to a gfx::Font::Weight. For
+  // example San Francisco on macOS 10.12 goes up from 0 in the sequence:
+  // [0.23, 0.23, 0.3, 0.4, 0.56, 0.62, 0.62, ...] and has no "thin" weights.
+  // But also iterating over weights does weird stuff sometimes - occasionally
+  // the font goes italic, but going up another step goes back to non-italic,
+  // at a heavier weight.
+
+  // NSCTFontUIUsageAttribute = CTFontMediumUsage.
+  ns_font = [manager convertWeight:up ofFont:ns_font];         // 0.23.
+  EXPECT_EQ(Font::Weight::MEDIUM, Font(ns_font).GetWeight());  // Row 6.
+
+  // Goes italic: NSCTFontUIUsageAttribute = CTFontMediumItalicUsage.
+  ns_font = [manager convertWeight:up ofFont:ns_font];         // 0.23.
+  EXPECT_EQ(Font::Weight::MEDIUM, Font(ns_font).GetWeight());  // Row 7.
+
+  // NSCTFontUIUsageAttribute = CTFontDemiUsage.
+  ns_font = [manager convertWeight:up ofFont:ns_font];  // 0.3.
+  if (base::mac::IsOS10_10()) {
+    // 10.10 is Helvetica Neue. It only has NORMAL, MEDIUM, BOLD and BLACK.
+    EXPECT_EQ(Font::Weight::BOLD, Font(ns_font).GetWeight());  // Row 8.
+  } else {
+    EXPECT_EQ(Font::Weight::SEMIBOLD, Font(ns_font).GetWeight());  // Row 8.
+  }
+
+  // NSCTFontUIUsageAttribute = CTFontEmphasizedUsage.
+  ns_font = [manager convertWeight:up ofFont:ns_font];  // 0.4 on 10.11+.
+
+  if (base::mac::IsOS10_10()) {
+    // Remaining rows are all BLACK on 10.10.
+    for (int row = 9; row <= 14; ++row) {
+      SCOPED_TRACE(testing::Message() << "Row: " << row);
+      ns_font = [manager convertWeight:up ofFont:ns_font];
+      EXPECT_EQ(Font::Weight::BLACK, Font(ns_font).GetWeight());
+    }
+    return;
+  }
+  EXPECT_EQ(Font::Weight::BOLD, Font(ns_font).GetWeight());  // Row 9.
+
+  // NSCTFontUIUsageAttribute = CTFontHeavyUsage.
+  ns_font = [manager convertWeight:up ofFont:ns_font];             // 0.56.
+  EXPECT_EQ(Font::Weight::EXTRA_BOLD, Font(ns_font).GetWeight());  // Row 10.
+
+  // NSCTFontUIUsageAttribute = CTFontBlackUsage.
+  ns_font = [manager convertWeight:up ofFont:ns_font];        // 0.62.
+  EXPECT_EQ(Font::Weight::BLACK, Font(ns_font).GetWeight());  // Row 11.
+  ns_font = [manager convertWeight:up ofFont:ns_font];        // 0.62.
+  EXPECT_EQ(Font::Weight::BLACK, Font(ns_font).GetWeight());  // Row 12.
+  ns_font = [manager convertWeight:up ofFont:ns_font];        // 0.62.
+  EXPECT_EQ(Font::Weight::BLACK, Font(ns_font).GetWeight());  // Row 13.
+  ns_font = [manager convertWeight:up ofFont:ns_font];        // 0.62.
+  EXPECT_EQ(Font::Weight::BLACK, Font(ns_font).GetWeight());  // Row 14.
+}
+
+// Test font derivation for fine-grained font weights.
+TEST(PlatformFontMacTest, DerivedFineGrainedFonts) {
+  // Only test where San Francisco is available.
+  if (base::mac::IsAtMostOS10_10())
+    return;
+
+  using Weight = Font::Weight;
+  Font base([NSFont systemFontOfSize:13]);
+
+  // The resulting, actual font weight after deriving |weight| from |base|.
+  auto DerivedWeight = [&](Weight weight) {
+    Font derived(base.Derive(0, 0, weight));
+    // PlatformFont should always pass the requested weight, not what the OS
+    // could provide. This just checks a constructor argument, so not very
+    // interesting.
+    EXPECT_EQ(weight, derived.GetWeight());
+
+    // Return the weight enum value that PlatformFontMac internally derives from
+    // the floating point weight given by the kCTFontWeightTrait of |font|. Do
+    // this by creating a new font based only off the NSFont in |derived|.
+    return Font(derived.GetNativeFont()).GetWeight();
+  };
+
+  // Only use NORMAL or BOLD as a base font. Mac font APIs go whacky otherwise.
+  // See comments in PlatformFontMac::DeriveFont().
+  for (Weight base_weight : {Weight::NORMAL, Weight::BOLD}) {
+    SCOPED_TRACE(testing::Message()
+                 << "BaseWeight: " << static_cast<int>(base_weight));
+    if (base_weight != Weight::NORMAL) {
+      base = base.Derive(0, 0, base_weight);
+      EXPECT_EQ(base_weight, base.GetWeight());
+    }
+
+    // Normal and heavy weights map correctly on 10.11 and 10.12.
+    EXPECT_EQ(Weight::NORMAL, DerivedWeight(Weight::NORMAL));
+    EXPECT_EQ(Weight::BOLD, DerivedWeight(Weight::BOLD));
+    EXPECT_EQ(Weight::EXTRA_BOLD, DerivedWeight(Weight::EXTRA_BOLD));
+    EXPECT_EQ(Weight::BLACK, DerivedWeight(Weight::BLACK));
+
+    if (base::mac::IsAtMostOS10_11()) {
+      // The fine-grained font weights on 10.11 are incomplete.

[tapted, 2017/05/22 01:16:37]

Naive of me to think that there was even one OS version where Apple didn't mess
around with their fonts :/.. 10.11 is San Francisco but a "different" San
Francisco, which is missing some weights. It's consistent otherwise though.

The other OSes were happy in the waterfall

https://build.chromium.org/p/chromium.mac/builders/Mac10.9%20Tests/builds/41470
https://build.chromium.org/p/chromium.mac/builders/Mac10.10%20Tests/builds/18212
https://build.chromium.org/p/chromium.mac/builders/Mac10.12%20Tests/builds/730

+      EXPECT_EQ(Weight::NORMAL, DerivedWeight(Weight::EXTRA_LIGHT));
+      EXPECT_EQ(Weight::NORMAL, DerivedWeight(Weight::THIN));
+      EXPECT_EQ(Weight::NORMAL, DerivedWeight(Weight::LIGHT));
+      EXPECT_EQ(Weight::BOLD, DerivedWeight(Weight::MEDIUM));
+      EXPECT_EQ(Weight::BOLD, DerivedWeight(Weight::SEMIBOLD));
+      continue;
+    }
+
+    // San Francisco doesn't offer anything between THIN and LIGHT.
+    EXPECT_EQ(Weight::THIN, DerivedWeight(Weight::EXTRA_LIGHT));
+
+    // All the rest should map correctly.
+    EXPECT_EQ(Weight::THIN, DerivedWeight(Weight::THIN));
+    EXPECT_EQ(Weight::LIGHT, DerivedWeight(Weight::LIGHT));
+    EXPECT_EQ(Weight::NORMAL, DerivedWeight(Weight::NORMAL));
+    EXPECT_EQ(Weight::MEDIUM, DerivedWeight(Weight::MEDIUM));
+    EXPECT_EQ(Weight::SEMIBOLD, DerivedWeight(Weight::SEMIBOLD));
+  }
 }
 
 // Ensures that the Font's reported height is consistent with the native font's
 // ascender and descender metrics.
 TEST(PlatformFontMacTest, ValidateFontHeight) {
   // Use the default ResourceBundle system font. E.g. Helvetica Neue in 10.10,
   // Lucida Grande before that, and San Francisco after.
   gfx::Font default_font;
   gfx::Font::FontStyle styles[] = {gfx::Font::NORMAL, gfx::Font::ITALIC,
                                    gfx::Font::UNDERLINE};
@@ skipping 24 matching lines @@
       // (plus baseline). So the height depends on the rounding of the ascender,
       // and can be as much as 1 greater than the simple sum of floats.
       EXPECT_LE(sum, font.GetHeight());
       EXPECT_GE(sum + 1, font.GetHeight());
 
       // Recreate the rounding performed for GetBaseLine().
       EXPECT_EQ(ceil(ceil(ascender) - descender + leading), font.GetHeight());
     }
   }
 }
+
+}  // namespace gfx