Re-land "Don't check lfQuality in LOGFONT as it has no effect on rendering""

Source/platform/fonts/win/FontPlatformDataWin.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Computer, Inc.
  * Copyright (c) 2006, 2007, 2008, 2009, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 67 matching lines @@
     SkASSERT(!(textFlags & ~textFlagsMask));
     uint32_t flags = paint->getFlags();
     flags &= ~textFlagsMask;
     flags |= textFlags;
     paint->setFlags(flags);
 }
 
 // Lookup the current system settings for font smoothing.
 // We cache these values for performance, but if the browser has a way to be
 // notified when these change, we could re-query them at that time.
-static uint32_t getDefaultGDITextFlags()
+static uint32_t getSystemTextFlags()
 {
     static bool gInited;
     static uint32_t gFlags;
     if (!gInited) {
         BOOL enabled;
         gFlags = 0;
         if (SystemParametersInfo(SPI_GETFONTSMOOTHING, 0, &enabled, 0) && enabled) {
             gFlags |= SkPaint::kAntiAlias_Flag;
 
             UINT smoothType;
             if (SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &smoothType, 0)) {
                 if (FE_FONTSMOOTHINGCLEARTYPE == smoothType)
                     gFlags |= SkPaint::kLCDRenderText_Flag;
             }
         }
         gInited = true;
     }
     return gFlags;
 }
 
-static bool isWebFont(const LOGFONT& lf)
+static bool isWebFont(const String& familyName)
 {
-    // web-fonts have artifical names constructed to always be
+    // Web-fonts have artifical names constructed to always be:
     // 1. 24 characters, followed by a '\0'
     // 2. the last two characters are '=='
-    return '=' == lf.lfFaceName[22] && '=' == lf.lfFaceName[23] && '\0' == lf.lfFaceName[24];
+    return familyName.length() == 24
+        && '=' == familyName[22] && '=' == familyName[23];
 }
 
-static int computePaintTextFlags(const LOGFONT& lf)
+static int computePaintTextFlags()

[bungeman-skia, 2014/02/11 15:42:56]

computePaintTextFlags(bool isWebFont)

this is static, how is it calling fontFamilyName()?

 {
-    int textFlags = 0;
-    switch (lf.lfQuality) {
-    case NONANTIALIASED_QUALITY:
-        textFlags = 0;
-        break;
-    case ANTIALIASED_QUALITY:
-        textFlags = SkPaint::kAntiAlias_Flag;
-        break;
-    case CLEARTYPE_QUALITY:
-        textFlags = (SkPaint::kAntiAlias_Flag | SkPaint::kLCDRenderText_Flag);
-        break;
-    default:
-        textFlags = getDefaultGDITextFlags();
-        break;
-    }
+    int textFlags = getSystemTextFlags();
 
-    // only allow features that SystemParametersInfo allows
-    textFlags &= getDefaultGDITextFlags();
-
-    /*
-     *  FontPlatformData(...) will read our logfont, and try to honor the the lfQuality
-     *  setting (computing the corresponding SkPaint flags for AA and LCD). However, it
-     *  will limit the quality based on its query of SPI_GETFONTSMOOTHING. This could mean
-     *  we end up drawing the text in BW, even though our lfQuality requested antialiasing.
-     *
-     *  Many web-fonts are so poorly hinted that they are terrible to read when drawn in BW.
-     *  In these cases, we have decided to FORCE these fonts to be drawn with at least grayscale AA,
-     *  even when the System (getDefaultGDITextFlags) tells us to draw only in BW.
-     */
-    if (isWebFont(lf) && !isRunningLayoutTest())
+    // Many web-fonts are so poorly hinted that they are terrible to read when drawn in BW.
+    // In these cases, we have decided to FORCE these fonts to be drawn with at least grayscale AA,
+    // even when the System (getSystemTextFlags) tells us to draw only in BW.
+    if (isWebFont(fontFamilyName()) && !isRunningLayoutTest())
         textFlags |= SkPaint::kAntiAlias_Flag;
     return textFlags;
 }
 
 #if !USE(HARFBUZZ)
-PassRefPtr<SkTypeface> CreateTypefaceFromHFont(HFONT hfont, int* size, int* paintTextFlags)
+PassRefPtr<SkTypeface> CreateTypefaceFromHFont(HFONT hfont, int* size)
 {
     LOGFONT info;
     GetObject(hfont, sizeof(info), &info);
     if (size) {
         int height = info.lfHeight;
         if (height < 0)
             height = -height;
         *size = height;
     }
-    if (paintTextFlags)
-        *paintTextFlags = computePaintTextFlags(info);
     return adoptRef(SkCreateTypefaceFromLOGFONT(info));
 }
 #endif
 
 FontPlatformData::FontPlatformData(WTF::HashTableDeletedValueType)
     : m_textSize(-1)
     , m_syntheticBold(false)
     , m_syntheticItalic(false)
     , m_orientation(Horizontal)
     , m_typeface(adoptRef(SkTypeface::RefDefault()))
@@ skipping 24 matching lines @@
 }
 
 #if ENABLE(GDI_FONTS_ON_WINDOWS) && !USE(HARFBUZZ)
 FontPlatformData::FontPlatformData(HFONT font, float size, FontOrientation orientation)
     : m_font(RefCountedHFONT::create(font))
     , m_textSize(size)
     , m_syntheticBold(false)
     , m_syntheticItalic(false)
     , m_orientation(orientation)
     , m_scriptCache(0)
-    , m_typeface(CreateTypefaceFromHFont(font, 0, &m_paintTextFlags))
+    , m_typeface(CreateTypefaceFromHFont(font, 0))
     , m_isHashTableDeletedValue(false)
     , m_useSubpixelPositioning(false)
 {
+    m_paintTextFlags = computePaintTextFlags();
 }
 #endif
 
 // FIXME: this constructor is needed for SVG fonts but doesn't seem to do much
 FontPlatformData::FontPlatformData(float size, bool bold, bool oblique)
     : m_textSize(size)
     , m_syntheticBold(false)
     , m_syntheticItalic(false)
     , m_orientation(Horizontal)
     , m_typeface(adoptRef(SkTypeface::RefDefault()))
@@ skipping 48 matching lines @@
     , m_orientation(orientation)
     , m_typeface(tf)
     , m_isHashTableDeletedValue(false)
     , m_useSubpixelPositioning(useSubpixelPositioning)
 {
     // FIXME: This can be removed together with m_font once the last few
     // uses of hfont() has been eliminated.
     LOGFONT logFont;
     SkLOGFONTFromTypeface(m_typeface.get(), &logFont);
     logFont.lfHeight = -textSize;
     m_paintTextFlags = computePaintTextFlags(logFont);

[bungeman-skia, 2014/02/11 15:42:56]

computeTextFlags doesn't take a param anymore?

 
 #if !USE(HARFBUZZ)
     HFONT hFont = CreateFontIndirect(&logFont);
     m_font = hFont ? RefCountedHFONT::create(hFont) : 0;
     m_scriptCache = 0;
 #endif
 }
 
 FontPlatformData& FontPlatformData::operator=(const FontPlatformData& data)
 {
@@ skipping 146 matching lines @@
 }
 
 #ifndef NDEBUG
 String FontPlatformData::description() const
 {
     return String();
 }
 #endif
 
 } // namespace WebCore