Fix CJK font linking size on Windows XP.

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 <math.h>
 
 #include <algorithm>
@@ skipping 29 matching lines @@
     min_font_size = gfx::PlatformFontWin::get_minimum_font_size_callback();
   // Make sure lf_height is not smaller than allowed min font size for current
   // locale.
   if (abs(lf_height) < min_font_size) {
     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::UNDERLINED) == gfx::Font::UNDERLINED);

[msw, 2012/04/26 21:04:42]

Just set the bool to the bit-wise & value (kinda like Bold).
Otherwise, comparing against 0 should fit on the line above.
Please make italic consistent if you do make a change here.

[Alexei Svitkine (slow), 2012/04/26 21:45:56]

Done. I used != 0 since I don't know if passing values other than 0 and 1 would
cause a problem for CreateFontIndirect().

(Note: The previous code was being extra safe - since for example if one of
those flags was defined to be more than one bit, comparing against zero is not
correct. But that's not the case and unlikely to change, so I've simplified it
as you suggest).

+  font_info->lfItalic = ((font_style & gfx::Font::ITALIC) == gfx::Font::ITALIC);
+  font_info->lfWeight = (font_style & gfx::Font::BOLD) ? FW_BOLD : FW_NORMAL;
+}
+
 }  // namespace
 
 namespace gfx {
 
 // static
 PlatformFontWin::HFontRef* PlatformFontWin::base_font_ref_;
 
 // static
 PlatformFontWin::AdjustFontCallback
     PlatformFontWin::adjust_font_callback = NULL;
 PlatformFontWin::GetMinimumFontSizeCallback
     PlatformFontWin::get_minimum_font_size_callback = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin, public
 
 PlatformFontWin::PlatformFontWin() : font_ref_(GetBaseFontRef()) {
 }
 
 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) {
+  DCHECK_GE(height, 0);
+  if (GetHeight() == height && GetStyle() == style)
+    return Font(this);
+
+  LOGFONT font_info;
+  GetObject(GetNativeFont(), sizeof(LOGFONT), &font_info);
+  font_info.lfHeight = height;
+  SetLogFontStyle(style, &font_info);
+
+  HFONT hfont = CreateFontIndirect(&font_info);
+  return Font(new PlatformFontWin(CreateHFontRef(hfont)));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin, PlatformFont implementation:
 
 Font PlatformFontWin::DeriveFont(int size_delta, int style) const {
   LOGFONT font_info;
   GetObject(GetNativeFont(), sizeof(LOGFONT), &font_info);
   font_info.lfHeight = AdjustFontSize(font_info.lfHeight, size_delta);
-  font_info.lfUnderline =
-      ((style & gfx::Font::UNDERLINED) == gfx::Font::UNDERLINED);
-  font_info.lfItalic = ((style & gfx::Font::ITALIC) == gfx::Font::ITALIC);
-  font_info.lfWeight = (style & gfx::Font::BOLD) ? FW_BOLD : FW_NORMAL;
+  SetLogFontStyle(style, &font_info);
 
   HFONT hfont = CreateFontIndirect(&font_info);
   return Font(new PlatformFontWin(CreateHFontRef(hfont)));
 }
 
 int PlatformFontWin::GetHeight() const {
   return font_ref_->height();
 }
 
 int PlatformFontWin::GetBaseline() const {
@@ skipping 85 matching lines @@
 PlatformFontWin::HFontRef* PlatformFontWin::CreateHFontRef(HFONT font) {
   TEXTMETRIC font_metrics;
 
   {
     base::win::ScopedGetDC screen_dc(NULL);
     base::win::ScopedSelectObject font(screen_dc, font);
     ui::ScopedSetMapMode mode(screen_dc, MM_TEXT);
     GetTextMetrics(screen_dc, &font_metrics);
   }
 
-  const int height = std::max(1, static_cast<int>(font_metrics.tmHeight));
-  const int baseline = std::max(1, static_cast<int>(font_metrics.tmAscent));
-  const int ave_char_width =
-      std::max(1, static_cast<int>(font_metrics.tmAveCharWidth));
+  const int height = std::max<int>(1, font_metrics.tmHeight);

[msw, 2012/04/26 21:04:42]

nice :)

+  const int baseline = std::max<int>(1, font_metrics.tmAscent);
+  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::UNDERLINED;
   if (font_metrics.tmWeight >= kTextMetricWeightBold)
     style |= Font::BOLD;
 
-  return new HFontRef(font, height, baseline, ave_char_width, style);
+  return new HFontRef(font, font_size, height, baseline, ave_char_width, style);

[msw, 2012/04/26 21:04:42]

Seems like HFontRef's ctor should just take (HFONT font, TEXTMETRIC
font_metrics, int style). Perhaps that's not in the scope of this CL, but this
is its only callsite...

[Alexei Svitkine (slow), 2012/04/26 21:45:56]

I agree, but let's leave it for another CL.

[msw, 2012/04/26 22:14:13]

SGTM.

 }
 
 PlatformFontWin::PlatformFontWin(HFontRef* hfont_ref) : font_ref_(hfont_ref) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PlatformFontWin::HFontRef:
 
 PlatformFontWin::HFontRef::HFontRef(HFONT hfont,
+         int font_size,
          int height,
          int baseline,
          int ave_char_width,
          int style)
     : hfont_(hfont),
+      font_size_(font_size),
       height_(height),
       baseline_(baseline),
       ave_char_width_(ave_char_width),
       style_(style),
       dlu_base_x_(-1) {
   DLOG_ASSERT(hfont);
 
   LOGFONT font_info;
   GetObject(hfont_, sizeof(LOGFONT), &font_info);
   font_name_ = UTF16ToUTF8(string16(font_info.lfFaceName));
-  DCHECK_LT(font_info.lfHeight, 0);
-  font_size_ = -font_info.lfHeight;
 }
 
 int PlatformFontWin::HFontRef::GetDluBaseX() {
   if (dlu_base_x_ != -1)
     return dlu_base_x_;
 
   base::win::ScopedGetDC screen_dc(NULL);
   base::win::ScopedSelectObject font(screen_dc, hfont_);
   ui::ScopedSetMapMode mode(screen_dc, MM_TEXT);
 
@@ skipping 26 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