Fix CJK font linking size on Windows XP.

ui/gfx/render_text_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/render_text_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
+#include "base/win/windows_version.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_smoothing_win.h"
-#include "ui/gfx/platform_font.h"
+#include "ui/gfx/platform_font_win.h"
 
 namespace {
 
 // The maximum supported number of Uniscribe runs; a SCRIPT_ITEM is 8 bytes.
 // TODO(msw): Review memory use/failure? Max string length? Alternate approach?
 const int kGuessItems = 100;
 const int kMaxItems = 10000;
 
 // The maximum supported number of Uniscribe glyphs; a glyph is 1 word.
 // TODO(msw): Review memory use/failure? Max string length? Alternate approach?
@@ skipping 80 matching lines @@
     if ((index != string16::npos) && (index + 1 != values[i].length())) {
       const std::string linked_name = UTF16ToUTF8(values[i].substr(index + 1));
       const gfx::Font linked_font(linked_name, font.GetFontSize());
       linked_fonts->push_back(linked_font);
     }
   }
 
   key.Close();
 }
 
-// Changes |font| to have the specified |font_size| and |font_style| if it does
-// not already. Only considers bold and italic styles, since the underlined
-// style has no effect on glyph shaping.
-void DeriveFontIfNecessary(int font_size, int font_style, gfx::Font* font) {
+// Changes |font| to have the specified |font_size| (or |font_height| on Windows
+// XP) and |font_style| if it is not the case already. Only considers bold and
+// italic styles, since the underlined style has no effect on glyph shaping.
+void DeriveFontIfNecessary(int font_size,

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

It would be nice to have this function take a const Font& font for the target
size/height/style, then using the size/height per platform is more of an impl
detail.

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

That won't work for the call site that applies the style to the font, the style
would have to come from a parameter and not the const font.

It would also be a bit confusing, because now it would take two fonts as
parameters - one for the reference size, and the other for the other
characteristics (e.g. font name) and the output parameter.

Right now, it's clear that the single font param is the font that may be changed
according to the other parameters. It's much less confusing than what you're
proposing.

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

Fair enough, I agree :), the function comment suffices to explain why it takes a
height and a size, which is the minor confusing implementation detail i was
trying to encapsulate.

+                           int font_height,
+                           int font_style,
+                           gfx::Font* font) {
   const int kStyleMask = (gfx::Font::BOLD | gfx::Font::ITALIC);
+  const int target_style = (font_style & kStyleMask);
+
+  // On Windows XP, the font must be resized using |font_height| instead of
+  // |font_size| to match GDI behavior.
+  if (base::win::GetVersion() < base::win::VERSION_VISTA) {
+    gfx::PlatformFontWin* platform_font =
+        static_cast<gfx::PlatformFontWin*>(font->platform_font());
+    *font = platform_font->DeriveFontWithHeight(font_height, target_style);
+    return;
+  }
+
   const int current_style = (font->GetStyle() & kStyleMask);
-  const int target_style = (font_style & kStyleMask);
   const int current_size = font->GetFontSize();
-  if (current_style != target_style || current_size != font_size)
-    *font = font->DeriveFont(font_size - current_size, font_style);
+  if (current_style != target_style || current_size != font->GetFontSize())
+    *font = font->DeriveFont(font_size - font->GetFontSize(), font_style);
 }
 
 }  // namespace
 
 namespace gfx {
 
 namespace internal {
 
 TextRun::TextRun()
   : strike(false),
@@ skipping 416 matching lines @@
   // TODO(msw): Only break for font changes, not color etc. See TextRun comment.
   StyleRanges styles(style_ranges());
   ApplyCompositionAndSelectionStyles(&styles);
   StyleRanges::const_iterator style = styles.begin();
   SCRIPT_ITEM* script_item = &script_items[0];
   for (int run_break = 0; run_break < text_length;) {
     internal::TextRun* run = new internal::TextRun();
     run->range.set_start(run_break);
     run->font = GetFont();
     run->font_style = style->font_style;
-    DeriveFontIfNecessary(run->font.GetFontSize(), run->font_style, &run->font);
+    DeriveFontIfNecessary(run->font.GetFontSize(), run->font.GetHeight(),
+                          run->font_style, &run->font);
     run->foreground = style->foreground;
     run->strike = style->strike;
     run->diagonal_strike = style->diagonal_strike;
     run->underline = style->underline;
     run->script_analysis = script_item->a;
 
     // Find the range end and advance the structures as needed.
     int script_item_end = (script_item + 1)->iCharPos;
     int style_range_end = style->range.end();
     run_break = std::min(script_item_end, style_range_end);
@@ skipping 163 matching lines @@
     const ABC& abc = run->abc_widths;
     run->width = abc.abcA + abc.abcB + abc.abcC;
     preceding_run_widths += run->width;
   }
   string_size_.set_width(preceding_run_widths);
 }
 
 void RenderTextWin::ApplySubstituteFont(internal::TextRun* run,
                                         const Font& font) {
   const int font_size = run->font.GetFontSize();
+  const int font_height = run->font.GetHeight();
   run->font = font;
-  DeriveFontIfNecessary(font_size, run->font_style, &run->font);
+  DeriveFontIfNecessary(font_size, font_height, run->font_style, &run->font);
   ScriptFreeCache(&run->script_cache);
   SelectObject(cached_hdc_, run->font.GetNativeFont());
 }
 
 const std::vector<Font>* RenderTextWin::GetLinkedFonts(const Font& font) const {
   const std::string& font_name = font.GetFontName();
   std::map<std::string, std::vector<Font> >::const_iterator it =
       cached_linked_fonts_.find(font_name);
   if (it != cached_linked_fonts_.end())
     return &it->second;
@@ skipping 36 matching lines @@
     internal::TextRun* run) {
   size_t caret = IndexOfAdjacentGrapheme(run->range.end(), CURSOR_BACKWARD);
   return SelectionModel(caret, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx