Fix CJK font linking size on Windows XP.

ui/gfx/platform_font_win.h

 // 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.
 
 #ifndef UI_GFX_PLATFORM_FONT_WIN_H_
 #define UI_GFX_PLATFORM_FONT_WIN_H_
 #pragma once
 
 #include <string>
 
@@ skipping 29 matching lines @@
   // performed other than clamping to a minimum font height if
   // |get_minimum_font_size_callback| is specified.
   typedef void (*AdjustFontCallback)(LOGFONT* lf);
   static AdjustFontCallback adjust_font_callback;
 
   // Returns the font name for the system locale. Some fonts, particularly
   // East Asian fonts, have different names per locale. If the localized font
   // name could not be retrieved, returns GetFontName().
   std::string GetLocalizedFontName() const;
 
+  // Returns a derived Font with the specified |style| and with height at most
+  // |height|. If the height and style of the receiver already match, it is
+  // returned. Otherwise, the returned Font will have the largest size such that
+  // its height is less than or equal to |height| (since there may not exist a
+  // size that matches the exact |height| specified).
+  Font DeriveFontWithHeight(int height, int style);
+
   // Overridden from PlatformFont:
   virtual Font DeriveFont(int size_delta, int style) const OVERRIDE;
   virtual int GetHeight() const OVERRIDE;
   virtual int GetBaseline() const OVERRIDE;
   virtual int GetAverageCharacterWidth() const OVERRIDE;
   virtual int GetStringWidth(const string16& text) const OVERRIDE;
   virtual int GetExpectedTextWidth(int length) const OVERRIDE;
   virtual int GetStyle() const OVERRIDE;
   virtual std::string GetFontName() const OVERRIDE;
   virtual int GetFontSize() const OVERRIDE;
   virtual NativeFont GetNativeFont() const OVERRIDE;
 
  private:
   virtual ~PlatformFontWin() {}
 
   // Chrome text drawing bottoms out in the Windows GDI functions that take an
   // HFONT (an opaque handle into Windows). To avoid lots of GDI object
   // allocation and destruction, Font indirectly refers to the HFONT by way of
   // an HFontRef. That is, every Font has an HFontRef, which has an HFONT.
   //
   // HFontRef is reference counted. Upon deletion, it deletes the HFONT.
   // By making HFontRef maintain the reference to the HFONT, multiple
   // HFontRefs can share the same HFONT, and Font can provide value semantics.
   class HFontRef : public base::RefCounted<HFontRef> {
    public:
     // This constructor takes control of the HFONT, and will delete it when
     // the HFontRef is deleted.
     HFontRef(HFONT hfont,
+             int font_size,
              int height,
              int baseline,
              int ave_char_width,
              int style);
 
     // Accessors
     HFONT hfont() const { return hfont_; }
     int height() const { return height_; }
     int baseline() const { return baseline_; }
     int ave_char_width() const { return ave_char_width_; }
     int style() const { return style_; }
     const std::string& font_name() const { return font_name_; }
     int font_size() const { return font_size_; }
+    int requested_font_size() const { return requested_font_size_; }
 
     // Returns the average character width in dialog units.
     int GetDluBaseX();
 
    private:
     friend class base::RefCounted<HFontRef>;
 
     ~HFontRef();
 
     const HFONT hfont_;
+    const int font_size_;
     const int height_;
     const int baseline_;
     const int ave_char_width_;
     const int style_;
     // Average character width in dialog units. This is queried lazily from the
     // system, with an initial value of -1 meaning it hasn't yet been queried.
     int dlu_base_x_;
     std::string font_name_;
-    int font_size_;
+
+    // If the requested font size is not possible for the font, |font_size_|
+    // will be different than |requested_font_size_|. This is stored separately
+    // so that code that increases the font size in a loop (as is done in some
+    // tests) will not cause the loop to get stuck on the same size.
+    int requested_font_size_;

[msw, 2012/04/30 17:40:01]

If this condition is limited to tests, and it's known behavior that the font
size may not match the requested size, then can the test account for the that,
instead of adding this member?

[Alexei Svitkine (slow), 2012/04/30 17:49:14]

It's not just test code, actually. I'm using it in DeriveFontWithHeight() too,
in the path that doesn't use CreateFontIndirect(). I removed the reference to
test code in the description.

[msw, 2012/04/30 18:55:39]

Oh wow, it took me a minute to fully grok why this is needed; it's a sad state
of affairs, but I don't see any clear alternative.

 
     DISALLOW_COPY_AND_ASSIGN(HFontRef);
   };
 
   // Initializes this object with a copy of the specified HFONT.
   void InitWithCopyOfHFONT(HFONT hfont);
 
   // Initializes this object with the specified font name and size.
   void InitWithFontNameAndSize(const std::string& font_name,
                                int font_size);
@@ skipping 13 matching lines @@
   static HFontRef* base_font_ref_;
 
   // Indirect reference to the HFontRef, which references the underlying HFONT.
   scoped_refptr<HFontRef> font_ref_;
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_PLATFORM_FONT_WIN_H_