Allow various font weights in gfx.

ui/gfx/platform_font_win_unittest.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/platform_font_win.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/scoped_select_object.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/win/direct_write.h"
 #include "ui/gfx/win/scoped_set_map_mode.h"
 
 namespace gfx {
 
 TEST(PlatformFontWinTest, DeriveFontWithHeight) {
   const Font base_font;
   PlatformFontWin* platform_font =
       static_cast<PlatformFontWin*>(base_font.platform_font());
 
   for (int i = -10; i < 10; i++) {
     const int target_height = base_font.GetHeight() + i;
 
-    Font derived_font = platform_font->DeriveFontWithHeight(target_height, 0);
+    Font derived_font = platform_font->DeriveFontWithHeight(
+        target_height, 0, gfx::Font::WEIGHT_NORMAL);
     EXPECT_LE(derived_font.GetHeight(), target_height);
-    EXPECT_GT(derived_font.Derive(1, 0).GetHeight(), target_height);
+    EXPECT_GT(derived_font.Derive(1, 0, gfx::Font::WEIGHT_NORMAL).GetHeight(),
+              target_height);
     EXPECT_EQ(platform_font->GetActualFontNameForTesting(),
               derived_font.GetActualFontNameForTesting());
     EXPECT_EQ(0, derived_font.GetStyle());
 
-    derived_font = platform_font->DeriveFontWithHeight(target_height,
-                                                       Font::BOLD);
+    derived_font = platform_font->DeriveFontWithHeight(target_height, 0,
+                                                       gfx::Font::WEIGHT_BOLD);
     EXPECT_LE(derived_font.GetHeight(), target_height);
-    EXPECT_GT(derived_font.Derive(1, 0).GetHeight(), target_height);
+    EXPECT_GT(derived_font.Derive(1, 0, gfx::Font::WEIGHT_NORMAL).GetHeight(),

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

nint: shouldn't this be bold to match the old behavior?

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

Nope, it should be like this because the weight on the left was normal
(Derive(1,0) means, derive me a font of size 1 larger with no styling, which the
WEIGHT_NORMAL exactly means).

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

Acknowledged.

+              target_height);
     EXPECT_EQ(platform_font->GetActualFontNameForTesting(),
               derived_font.GetActualFontNameForTesting());
-    EXPECT_EQ(Font::BOLD, derived_font.GetStyle());
+    EXPECT_EQ(Font::WEIGHT_BOLD, derived_font.GetWeight());
   }
 }
 
 TEST(PlatformFontWinTest, DeriveFontWithHeight_Consistency) {
   gfx::Font arial_12("Arial", 12);
   ASSERT_GT(16, arial_12.GetHeight());
-  gfx::Font derived_1 = static_cast<PlatformFontWin*>(
-      arial_12.platform_font())->DeriveFontWithHeight(16, 0);
+  gfx::Font derived_1 =
+      static_cast<PlatformFontWin*>(arial_12.platform_font())
+          ->DeriveFontWithHeight(16, 0, gfx::Font::WEIGHT_NORMAL);
 
   gfx::Font arial_15("Arial", 15);
   ASSERT_LT(16, arial_15.GetHeight());
-  gfx::Font derived_2 = static_cast<PlatformFontWin*>(
-      arial_15.platform_font())->DeriveFontWithHeight(16, 0);
+  gfx::Font derived_2 =
+      static_cast<PlatformFontWin*>(arial_15.platform_font())
+          ->DeriveFontWithHeight(16, 0, gfx::Font::WEIGHT_NORMAL);
 
   EXPECT_EQ(derived_1.GetFontSize(), derived_2.GetFontSize());
   EXPECT_EQ(16, derived_1.GetHeight());
   EXPECT_EQ(16, derived_2.GetHeight());
 }
 
 // Callback function used by DeriveFontWithHeight_MinSize() below.
 static int GetMinFontSize() {
   return 10;
 }
 
 TEST(PlatformFontWinTest, DeriveFontWithHeight_MinSize) {
   PlatformFontWin::GetMinimumFontSizeCallback old_callback =
     PlatformFontWin::get_minimum_font_size_callback;
   PlatformFontWin::get_minimum_font_size_callback = &GetMinFontSize;
 
   const Font base_font;
   const Font min_font(base_font.GetFontName(), GetMinFontSize());
   PlatformFontWin* platform_font =
       static_cast<PlatformFontWin*>(base_font.platform_font());
 
-  const Font derived_font =
-      platform_font->DeriveFontWithHeight(min_font.GetHeight() - 1, 0);
+  const Font derived_font = platform_font->DeriveFontWithHeight(
+      min_font.GetHeight() - 1, 0, gfx::Font::WEIGHT_NORMAL);
   EXPECT_EQ(min_font.GetFontSize(), derived_font.GetFontSize());
   EXPECT_EQ(min_font.GetHeight(), derived_font.GetHeight());
 
   PlatformFontWin::get_minimum_font_size_callback = old_callback;
 }
 
 TEST(PlatformFontWinTest, DeriveFontWithHeight_TooSmall) {
   const Font base_font;
   PlatformFontWin* platform_font =
       static_cast<PlatformFontWin*>(base_font.platform_font());
 
-  const Font derived_font = platform_font->DeriveFontWithHeight(1, 0);
+  const Font derived_font =
+      platform_font->DeriveFontWithHeight(1, 0, gfx::Font::WEIGHT_NORMAL);
   EXPECT_GT(derived_font.GetHeight(), 1);
 }
 
 // Test whether font metrics retrieved by DirectWrite (skia) and GDI match as
 // per assumptions mentioned below:-
 // 1. Font size is the same
 // 2. The difference between GDI and DirectWrite for font height, baseline,
 //    and cap height is at most 1. For smaller font sizes under 12, GDI
 //    font heights/baselines/cap height are equal/larger by 1 point. For larger
 //    font sizes DirectWrite font heights/baselines/cap height are equal/larger
@@ skipping 98 matching lines @@
     PlatformFontWin::GetTextMetricsForFont(screen_dc, hFont, &font_metrics);
 
     scoped_refptr<PlatformFontWin::HFontRef> h_font_skia(
         PlatformFontWin::CreateHFontRefFromSkia(hFont, font_metrics));
 
     EXPECT_EQ(font.expected_font_name, h_font_skia->font_name());
   }
 }
 
 }  // namespace gfx