Make RenderTextWin fallback match original font heights.

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/i18n/char_iterator.h"
@@ skipping 20 matching lines @@
 const size_t kMaxUniscribeTextLength = 10000;
 
 // The initial guess and maximum supported number of runs; arbitrary values.
 // TODO(msw): Support more runs, determine a better initial guess, etc.
 const int kGuessRuns = 100;
 const size_t kMaxRuns = 10000;
 
 // The maximum number of glyphs per run; ScriptShape fails on larger values.
 const size_t kMaxGlyphs = 65535;
 
-// 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,
-                           Font* font) {
+// Changes |font| to the specified |font_height| and bold/italic |font_style|.
+// Underlined styling is not considered, as it has no effect on glyph shaping.
+void DeriveFontIfNecessary(int height, int style, Font* font) {
   const int kStyleMask = (Font::BOLD | 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) {
-    PlatformFontWin* platform_font =
-        static_cast<PlatformFontWin*>(font->platform_font());
-    *font = platform_font->DeriveFontWithHeight(font_height, target_style);
-    return;
-  }
-
-  const int current_style = (font->GetStyle() & kStyleMask);
-  const int current_size = font->GetFontSize();
-  if (current_style != target_style || current_size != font_size)
-    *font = font->Derive(font_size - current_size, target_style);
+  PlatformFontWin* platform_font =
+      static_cast<PlatformFontWin*>(font->platform_font());
+  *font = platform_font->DeriveFontWithHeight(height, style & kStyleMask);
 }
 
 // Returns true if |c| is a Unicode BiDi control character.
 bool IsUnicodeBidiControlCharacter(base::char16 c) {
   return c == base::i18n::kRightToLeftMark ||
          c == base::i18n::kLeftToRightMark ||
          c == base::i18n::kLeftToRightEmbeddingMark ||
          c == base::i18n::kRightToLeftEmbeddingMark ||
          c == base::i18n::kPopDirectionalFormatting ||
          c == base::i18n::kLeftToRightOverride ||
@@ skipping 810 matching lines @@
   empty_colors.SetMax(layout_text_length);
   internal::StyleIterator style(empty_colors, styles());
   SCRIPT_ITEM* script_item = &script_items[0];
   const size_t max_run_length = kMaxGlyphs / 2;
   for (size_t run_break = 0; run_break < layout_text_length;) {
     internal::TextRun* run = new internal::TextRun();
     run->range.set_start(run_break);
     run->font = font_list().GetPrimaryFont();
     run->font_style = (style.style(BOLD) ? Font::BOLD : 0) |
                       (style.style(ITALIC) ? Font::ITALIC : 0);
-    DeriveFontIfNecessary(run->font.GetFontSize(), run->font.GetHeight(),
-                          run->font_style, &run->font);
+    DeriveFontIfNecessary(run->font.GetHeight(), run->font_style, &run->font);
     run->strike = style.style(STRIKE);
     run->diagonal_strike = style.style(DIAGONAL_STRIKE);
     run->underline = style.style(UNDERLINE);
     run->script_analysis = script_item->a;
 
     // Find the next break and advance the iterators as needed.
     const size_t script_item_break = (script_item + 1)->iCharPos;
     run_break = std::min(script_item_break,
                          TextIndexToLayoutIndex(style.GetRange().end()));
 
@@ skipping 206 matching lines @@
   //            See https://bugzilla.mozilla.org/show_bug.cgi?id=341500
   //            And http://maxradi.us/documents/uniscribe/
   run->script_analysis.eScript = SCRIPT_UNDEFINED;
 }
 
 HRESULT RenderTextWin::ShapeTextRunWithFont(internal::TextRun* run,
                                             const Font& font) {
   // Update the run's font only if necessary. If the two fonts wrap the same
   // PlatformFontWin object, their native fonts will have the same value.
   if (run->font.GetNativeFont() != font.GetNativeFont()) {
-    const int font_size = run->font.GetFontSize();
-    const int font_height = run->font.GetHeight();
+    const int original_height = run->font.GetHeight();
     run->font = font;
-    DeriveFontIfNecessary(font_size, font_height, run->font_style, &run->font);
+    DeriveFontIfNecessary(original_height, run->font_style, &run->font);
     ScriptFreeCache(&run->script_cache);
   }
 
   // Select the font desired for glyph generation.
   SelectObject(cached_hdc_, run->font.GetNativeFont());
 
   HRESULT hr = E_OUTOFMEMORY;
   const size_t run_length = run->range.length();
   const wchar_t* run_text = &(GetLayoutText()[run->range.start()]);
   // Guess the expected number of glyphs from the length of the run.
@@ skipping 88 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateNativeInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx