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,
+                           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);
 }
 
 }  // namespace
 
 namespace gfx {
 
 namespace internal {
@@ skipping 419 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