Relanding this with font test fixes for gdi.

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 <algorithm>
 #include <dwrite.h>
 #include <math.h>
 #include <windows.h>
@@ skipping 193 matching lines @@
   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) {
   DCHECK_GE(height, 0);
-  if (GetHeight() == height && GetStyle() == style)
-    return Font(this);
+
+  // Create a font with a height near that of the target height.
+  HFONT hfont = CreateFontWithHeight(height, style);
+  Font font(new PlatformFontWin(CreateHFontRef(hfont)));
+
+  // Respect the minimum font size constraint.
+  const int min_font_size = GetMinimumFontSize();
 
   // CreateFontIndirect() doesn't return the largest size for the given height
   // when decreasing the height. Iterate to find it.
-  if (GetHeight() > height) {
-    const int min_font_size = GetMinimumFontSize();
-    Font font = DeriveFont(-1, style);
-    int font_height = font.GetHeight();
-    int font_size = font.GetFontSize();
-    while (font_height > height && font_size != min_font_size) {
-      font = font.Derive(-1, style);
-      if (font_height == font.GetHeight() && font_size == font.GetFontSize())
+  if (font.GetHeight() > height) {
+    while ((font.GetHeight() > height) &&
+           (font.GetFontSize() >= min_font_size)) {
+      Font derived_font = font.Derive(-1, style);
+      if ((derived_font.GetFontSize() < min_font_size) ||
+          (derived_font.GetFontSize() == font.GetFontSize()))
         break;
-      font_height = font.GetHeight();
-      font_size = font.GetFontSize();
+      DCHECK_LT(derived_font.GetFontSize(), font.GetFontSize());
+      font = derived_font;
     }
     return font;
   }
 
-  LOGFONT font_info;
-  GetObject(GetNativeFont(), sizeof(LOGFONT), &font_info);
-  font_info.lfHeight = height;
-  SetLogFontStyle(style, &font_info);
-
-  HFONT hfont = CreateFontIndirect(&font_info);
-  return DeriveWithCorrectedSize(hfont);
+  while (font.GetHeight() <= height) {
+    Font derived_font = font.Derive(1, style);
+    if ((derived_font.GetHeight() > height) &&
+        (font.GetFontSize() >= min_font_size))
+      break;
+    DCHECK_GT(derived_font.GetFontSize(), font.GetFontSize());
+    font = derived_font;
+  }
+  return font;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin, PlatformFont implementation:
 
 Font PlatformFontWin::DeriveFont(int size_delta, int style) 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);
@@ skipping 165 matching lines @@
     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);
 }
 
-Font PlatformFontWin::DeriveWithCorrectedSize(HFONT base_font) {
-  base::win::ScopedGetDC screen_dc(NULL);
-  gfx::ScopedSetMapMode mode(screen_dc, MM_TEXT);
-
-  base::win::ScopedGDIObject<HFONT> best_font(base_font);
-  TEXTMETRIC best_font_metrics;
-  GetTextMetricsForFont(screen_dc, best_font, &best_font_metrics);
-
-  LOGFONT font_info;
-  GetObject(base_font, sizeof(LOGFONT), &font_info);
-
-  // Set |lfHeight| to negative value to indicate it's the size, not the height.
-  font_info.lfHeight =
-      -(best_font_metrics.tmHeight - best_font_metrics.tmInternalLeading);
-
-  do {
-    // Increment font size. Prefer font with greater size if its height isn't
-    // greater than height of base font.
-    font_info.lfHeight = AdjustFontSize(font_info.lfHeight, 1);
-    base::win::ScopedGDIObject<HFONT> font(CreateFontIndirect(&font_info));
-    TEXTMETRIC font_metrics;
-    GetTextMetricsForFont(screen_dc, font, &font_metrics);
-    if (font_metrics.tmHeight > best_font_metrics.tmHeight)
-      break;
-    best_font.Set(font.release());
-    best_font_metrics = font_metrics;
-  } while (true);
-
-  return Font(new PlatformFontWin(CreateHFontRef(best_font.release())));
-}
-
 // 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
@@ skipping 44 matching lines @@
   SkPaint paint;
   paint.setAntiAlias(!!antialiasing);
   paint.setTypeface(skia_face.get());
   paint.setTextSize(-font_info.lfHeight);
   SkPaint::FontMetrics skia_metrics;
   paint.getFontMetrics(&skia_metrics);
 
   // The calculations below are similar to those in the CreateHFontRef
   // function. The height, baseline and cap height are rounded up to ensure
   // that they match up closely with GDI.
-  const int height = std::ceil(
-      skia_metrics.fDescent - skia_metrics.fAscent + skia_metrics.fLeading);
+  const int height = std::ceil(skia_metrics.fDescent - skia_metrics.fAscent);
   const int baseline = std::max<int>(1, std::ceil(-skia_metrics.fAscent));
   const int cap_height = std::ceil(paint.getTextSize() *
       static_cast<double>(dwrite_font_metrics.capHeight) /
           dwrite_font_metrics.designUnitsPerEm);
 
   // The metrics retrieved from skia don't have the average character width. In
   // any case if we get the average character width from skia then use that or
   // use the text extent technique as documented by microsoft. See
   // GetAverageCharWidthInDialogUnits for details.
   const int ave_char_width =
       skia_metrics.fAvgCharWidth == 0 ?
           HFontRef::GetAverageCharWidthInDialogUnits(gdi_font)
               : 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;
   return new HFontRef(gdi_font, -font_info.lfHeight, height, baseline,
                       cap_height, ave_char_width, style);
 }
 
 PlatformFontWin::PlatformFontWin(HFontRef* hfont_ref) : font_ref_(hfont_ref) {
 }
 
+HFONT PlatformFontWin::CreateFontWithHeight(int height, int style) {

[msw, 2015/01/13 23:54:59]

I don't think that this simplifies the code as you intended. Now we have a
function that creates an HFONT *similar* to what we need, using a loop, but it
still requires two loops to shrink or grow the font in the caller (since the
height of the HFONT doesn't map directly the height as reported by Skia,
right?). I'm not sure how this is better than making incremental improvements
like I suggested on the last patch set.

[ananta, 2015/01/14 00:17:23]

Reverted this part of the change. This was an experimental patch to see if it
helps in reducing the complexity in the DeriveFontWithHeight function.

+  LOGFONT font_info;
+  GetObject(GetNativeFont(), sizeof(LOGFONT), &font_info);
+  font_info.lfHeight = height;
+  SetLogFontStyle(style, &font_info);
+
+  base::win::ScopedGetDC screen_dc(NULL);
+  gfx::ScopedSetMapMode mode(screen_dc, MM_TEXT);
+
+  base::win::ScopedGDIObject<HFONT> best_font(CreateFontIndirect(&font_info));
+
+  TEXTMETRIC best_font_metrics = {0};
+  GetTextMetricsForFont(screen_dc, best_font, &best_font_metrics);
+
+  // Set |lfHeight| to negative value to indicate it's the size, not the height.
+  font_info.lfHeight =
+      -(best_font_metrics.tmHeight - best_font_metrics.tmInternalLeading);
+
+  // Respect the minimum font size constraint.
+  const int min_font_size = GetMinimumFontSize();
+
+  do {
+    // Increment font size. Prefer font with greater size if its height isn't
+    // greater than height of base font. Exception being the case where we have
+    // a minimum font size being enforced.
+    font_info.lfHeight = AdjustFontSize(font_info.lfHeight, 1);
+    base::win::ScopedGDIObject<HFONT> font(CreateFontIndirect(&font_info));
+    TEXTMETRIC font_metrics = {0};
+    GetTextMetricsForFont(screen_dc, font, &font_metrics);
+    if ((font_metrics.tmHeight > best_font_metrics.tmHeight) &&
+        ((best_font_metrics.tmHeight - best_font_metrics.tmInternalLeading) >=
+              min_font_size)) {
+      break;
+    }
+    best_font.Set(font.release());
+    best_font_metrics = font_metrics;
+  } while (true);
+
+  return best_font.release();
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin::HFontRef:
 
 PlatformFontWin::HFontRef::HFontRef(HFONT hfont,
                                     int font_size,
                                     int height,
                                     int baseline,
                                     int cap_height,
                                     int ave_char_width,
                                     int style)
@@ skipping 59 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