Allow various font weights in gfx.

ui/gfx/platform_font_win.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 <windows.h>
 #include <dwrite.h>
 #include <limits.h>
 #include <math.h>
@@ skipping 49 matching lines @@
     return lf_height < 0 ? -min_font_size : min_font_size;
   } else {
     return lf_height;
   }
 }
 
 // Sets style properties on |font_info| based on |font_style|.
 void SetLogFontStyle(int font_style, LOGFONT* font_info) {
   font_info->lfUnderline = (font_style & gfx::Font::UNDERLINE) != 0;
   font_info->lfItalic = (font_style & gfx::Font::ITALIC) != 0;
-  font_info->lfWeight = (font_style & gfx::Font::BOLD) ? FW_BOLD : FW_NORMAL;
+}
+
+gfx::Font::FontWeight ToGfxFontWeight(int weight) {
+  return static_cast<gfx::Font::FontWeight>(weight);
 }
 
 // Returns the family name for the |IDWriteFont| interface passed in.
 // The family name is returned in the |family_name_ret| parameter.
 // Returns S_OK on success.
 // TODO(ananta)
 // Remove the CHECKs in this function once this stabilizes on the field.
 HRESULT GetFamilyNameFromDirectWriteFont(IDWriteFont* dwrite_font,
                                          base::string16* family_name_ret) {
   base::win::ScopedComPtr<IDWriteFontFamily> font_family;
@@ skipping 70 matching lines @@
   return hr;
 }
 
 // Returns a matching IDWriteFont for the |font_info| passed in. If we fail
 // to find a matching font, then we return the IDWriteFont corresponding to
 // the default font on the system.
 // Returns S_OK on success.
 // The contents of the LOGFONT pointer |font_info| may be modified on
 // return.
 HRESULT GetMatchingDirectWriteFont(LOGFONT* font_info,
                                    int font_style,

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

This only concerns italic now... change to |bool italic|?

                                    IDWriteFactory* factory,
                                    IDWriteFont** dwrite_font) {
   // First try the GDI compat route to get a matching DirectWrite font.
   // If that succeeds then we are good. If that fails then try and find a
   // match from the DirectWrite font collection.
   HRESULT hr = FindDirectWriteFontForLOGFONT(factory, font_info, dwrite_font);
   if (SUCCEEDED(hr))
     return hr;
 
   // Get a matching font from the system font collection exposed by
@@ skipping 58 matching lines @@
     // If we fail to find a matching font, then fallback to the first font in
     // the list. This is what skia does as well.
     hr = font_collection->GetFontFamily(0, font_family.Receive());
   }
 
   if (FAILED(hr)) {
     CHECK(false);
     return hr;
   }
 
-  DWRITE_FONT_WEIGHT weight = (font_style & SkTypeface::kBold)
-                            ? DWRITE_FONT_WEIGHT_BOLD
-                            : DWRITE_FONT_WEIGHT_NORMAL;
+  DWRITE_FONT_WEIGHT weight =
+      static_cast<DWRITE_FONT_WEIGHT>(font_info->lfWeight);
   DWRITE_FONT_STRETCH stretch = DWRITE_FONT_STRETCH_NORMAL;
   DWRITE_FONT_STYLE italic = (font_style & SkTypeface::kItalic)
                             ? DWRITE_FONT_STYLE_ITALIC
                             : DWRITE_FONT_STYLE_NORMAL;
 
   // The IDWriteFontFamily::GetFirstMatchingFont call fails on certain machines
   // for fonts like MS UI Gothic, Segoe UI, etc. It is not clear why these
   // fonts could be accessible to GDI and not to DirectWrite.
   // The code below adds some debug fields to help track down these failures.
   // 1. We get the matching font list for the font attributes passed in.
@@ skipping 49 matching lines @@
 
 PlatformFontWin::PlatformFontWin(NativeFont native_font) {
   InitWithCopyOfHFONT(native_font);
 }
 
 PlatformFontWin::PlatformFontWin(const std::string& font_name,
                                  int font_size) {
   InitWithFontNameAndSize(font_name, font_size);
 }
 
-Font PlatformFontWin::DeriveFontWithHeight(int height, int style) {
+Font PlatformFontWin::DeriveFontWithHeight(int height,
+                                           int style,
+                                           gfx::Font::FontWeight weight) {
   DCHECK_GE(height, 0);
 
   // Create a font with a height near that of the target height.
   LOGFONT font_info;
   GetObject(GetNativeFont(), sizeof(LOGFONT), &font_info);
   font_info.lfHeight = height;
+  font_info.lfWeight = weight;
   SetLogFontStyle(style, &font_info);
 
   HFONT hfont = CreateFontIndirect(&font_info);
   Font font(new PlatformFontWin(CreateHFontRef(hfont)));
 
   // Respect the minimum font size constraint.
   const int min_font_size = GetMinimumFontSize();
 
   // Used to avoid shrinking the font and expanding it.
   bool ran_shrink_loop = false;
 
   // Iterate to find the largest font with a height <= |height|.
   while ((font.GetHeight() > height) &&
          (font.GetFontSize() >= min_font_size)) {
     ran_shrink_loop = true;
-    Font derived_font = font.Derive(-1, style);
+    Font derived_font = font.Derive(-1, style, font.GetWeight());
     // Break the loop if the derived font is too small or hasn't shrunk at all.
     if ((derived_font.GetFontSize() < min_font_size) ||
         ((derived_font.GetFontSize() == font.GetFontSize()) &&
          (derived_font.GetHeight() == font.GetHeight())))
       break;
     font = derived_font;
   }
 
   while ((!ran_shrink_loop && font.GetHeight() <= height) ||
          (font.GetFontSize() < min_font_size)) {
-    Font derived_font = font.Derive(1, style);
+    Font derived_font = font.Derive(1, style, font.GetWeight());
     // Break the loop if the derived font is too large or hasn't grown at all.
     if (((derived_font.GetHeight() > height) &&
          (font.GetFontSize() >= min_font_size)) ||
         ((derived_font.GetFontSize() == font.GetFontSize()) &&
          (derived_font.GetHeight() == font.GetHeight())))
       break;
     font = derived_font;
   }
   return font;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin, PlatformFont implementation:
 
-Font PlatformFontWin::DeriveFont(int size_delta, int style) const {
+Font PlatformFontWin::DeriveFont(int size_delta,
+                                 int style,
+                                 gfx::Font::FontWeight weight) const {
   LOGFONT font_info;
   GetObject(GetNativeFont(), sizeof(LOGFONT), &font_info);
   const int requested_font_size = font_ref_->requested_font_size();
   font_info.lfHeight = AdjustFontSize(-requested_font_size, size_delta);
+  font_info.lfWeight = weight;
   SetLogFontStyle(style, &font_info);
 
   HFONT hfont = CreateFontIndirect(&font_info);
   return Font(new PlatformFontWin(CreateHFontRef(hfont)));
 }
 
 int PlatformFontWin::GetHeight() {
   return font_ref_->height();
 }
 
+gfx::Font::FontWeight PlatformFontWin::GetWeight() {
+  return font_ref_->weight();
+}
+
 int PlatformFontWin::GetBaseline() {
   return font_ref_->baseline();
 }
 
 int PlatformFontWin::GetCapHeight() {
   return font_ref_->cap_height();
 }
 
 int PlatformFontWin::GetExpectedTextWidth(int length) {
   return length * std::min(font_ref_->GetDluBaseX(),
@@ skipping 138 matching lines @@
   const int cap_height =
       std::max<int>(1, font_metrics.tmAscent - font_metrics.tmInternalLeading);
   const int ave_char_width = std::max<int>(1, font_metrics.tmAveCharWidth);
   const int font_size =
       std::max<int>(1, font_metrics.tmHeight - font_metrics.tmInternalLeading);
   int style = 0;
   if (font_metrics.tmItalic)
     style |= Font::ITALIC;
   if (font_metrics.tmUnderlined)
     style |= Font::UNDERLINE;
-  if (font_metrics.tmWeight >= kTextMetricWeightBold)
-    style |= Font::BOLD;
 
   return new HFontRef(font, font_size, height, baseline, cap_height,
-                      ave_char_width, style);
+                      ave_char_width, ToGfxFontWeight(font_metrics.tmWeight),
+                      style);
 }
 
 // static
 PlatformFontWin::HFontRef* PlatformFontWin::CreateHFontRefFromSkia(
     HFONT gdi_font,
     const TEXTMETRIC& font_metrics) {
   LOGFONT font_info = {0};
   GetObject(gdi_font, sizeof(LOGFONT), &font_info);
 
   // If the font height is passed in as 0, assume the height to be -1 to ensure
   // that we return the metrics for a 1 point font.
   // If the font height is positive it represents the rasterized font's cell
   // height. Calculate the actual height accordingly.
   if (font_info.lfHeight > 0) {
     font_info.lfHeight =
         font_metrics.tmInternalLeading - font_metrics.tmHeight;
   } else if (font_info.lfHeight == 0) {
     font_info.lfHeight = -1;
   }
 
   int skia_style = SkTypeface::kNormal;
-  if (font_info.lfWeight >= FW_SEMIBOLD &&
-      font_info.lfWeight <= FW_ULTRABOLD) {
+  if (font_info.lfWeight >= FW_SEMIBOLD && font_info.lfWeight <= FW_ULTRABOLD)
     skia_style |= SkTypeface::kBold;

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

This is ignored by GetMatchingDirectWriteFont now; update.

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

Done.

-  }
   if (font_info.lfItalic)
     skia_style |= SkTypeface::kItalic;
 
   // Skia does not return all values we need for font metrics. For e.g.
   // the cap height which indicates the height of capital letters is not
   // returned even though it is returned by DirectWrite.
   // TODO(ananta)
   // Fix SkScalerContext_win_dw.cpp to return all metrics we need from
   // DirectWrite and remove the code here which retrieves metrics from
   // DirectWrite to calculate the cap height.
   base::win::ScopedComPtr<IDWriteFont> dwrite_font;
   HRESULT hr = GetMatchingDirectWriteFont(&font_info,
                                           skia_style,
                                           direct_write_factory_,
                                           dwrite_font.Receive());
   if (FAILED(hr)) {
     CHECK(false);
     return nullptr;
   }
 
   DWRITE_FONT_METRICS dwrite_font_metrics = {0};
   dwrite_font->GetMetrics(&dwrite_font_metrics);
 
-  skia::RefPtr<SkTypeface> skia_face = skia::AdoptRef(
-      SkTypeface::CreateFromName(
-          base::SysWideToUTF8(font_info.lfFaceName).c_str(),
-                              static_cast<SkTypeface::Style>(skia_style)));
+  SkFontStyle skia_font_style(font_info.lfWeight, SkFontStyle::kNormal_Width,
+                              font_info.lfItalic ? SkFontStyle::kItalic_Slant
+                                                 : SkFontStyle::kUpright_Slant);
+
+  skia::RefPtr<SkTypeface> skia_face =
+      skia::AdoptRef(SkTypeface::CreateFromNameAndStyle(
+          base::SysWideToUTF8(font_info.lfFaceName).c_str(), skia_font_style));
 
   gfx::FontRenderParams font_params =
       gfx::GetFontRenderParams(gfx::FontRenderParamsQuery(), nullptr);
   SkFontHost::SetSubpixelOrder(
       gfx::FontRenderParams::SubpixelRenderingToSkiaLCDOrder(
           font_params.subpixel_rendering));
   SkFontHost::SetSubpixelOrientation(
       gfx::FontRenderParams::SubpixelRenderingToSkiaLCDOrientation(
           font_params.subpixel_rendering));
 
@@ skipping 20 matching lines @@
   // from DirectWrite.
   const int ave_char_width =
       skia_metrics.fAvgCharWidth == 0 ? font_metrics.tmAveCharWidth
               : skia_metrics.fAvgCharWidth;
 
   int style = 0;
   if (skia_style & SkTypeface::kItalic)
     style |= Font::ITALIC;
   if (font_info.lfUnderline)
     style |= Font::UNDERLINE;
-  if (font_info.lfWeight >= kTextMetricWeightBold)
-    style |= Font::BOLD;
 
   // DirectWrite may have substituted the GDI font name with a fallback
   // font. Ensure that it is updated here.
   DeleteObject(gdi_font);
   gdi_font = ::CreateFontIndirect(&font_info);
   return new HFontRef(gdi_font, -font_info.lfHeight, height, baseline,
-                      cap_height, ave_char_width, style);
+                      cap_height, ave_char_width,
+                      ToGfxFontWeight(font_metrics.tmWeight), style);
 }
 
 PlatformFontWin::PlatformFontWin(HFontRef* hfont_ref) : font_ref_(hfont_ref) {
 }
 
 PlatformFontWin::~PlatformFontWin() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin::HFontRef:
 
 PlatformFontWin::HFontRef::HFontRef(HFONT hfont,
                                     int font_size,
                                     int height,
                                     int baseline,
                                     int cap_height,
                                     int ave_char_width,
+                                    gfx::Font::FontWeight weight,
                                     int style)
     : hfont_(hfont),
       font_size_(font_size),
       height_(height),
       baseline_(baseline),
       cap_height_(cap_height),
       ave_char_width_(ave_char_width),
+      weight_(weight),
       style_(style),
       dlu_base_x_(-1),
       requested_font_size_(font_size) {
   DLOG_ASSERT(hfont);
 
   LOGFONT font_info;
   GetObject(hfont_, sizeof(LOGFONT), &font_info);
   font_name_ = base::UTF16ToUTF8(base::string16(font_info.lfFaceName));
 
   // Retrieve the font size from the GetTextMetrics API instead of referencing
@@ skipping 51 matching lines @@
   return new PlatformFontWin(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontWin(font_name, font_size);
 }
 
 }  // namespace gfx