Initial implementation of font-size-adjust

Source/core/css/resolver/FontBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2015 Collabora Ltd. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 101 matching lines @@
     set(PropertySetFlag::Weight);
 
     m_fontDescription.setWeight(fontWeight);
 }
 
 void FontBuilder::setSize(const FontDescription::Size& size)
 {
     setSize(m_fontDescription, size);
 }
 
+void FontBuilder::setSizeAdjust(float aspectValue)
+{
+    set(PropertySetFlag::SizeAdjust);
+
+    m_fontDescription.setSizeAdjust(aspectValue);
+}
+
 void FontBuilder::setStretch(FontStretch fontStretch)
 {
     set(PropertySetFlag::Stretch);
 
     m_fontDescription.setStretch(fontStretch);
 }
 
 void FontBuilder::setScript(const AtomicString& locale)
 {
     set(PropertySetFlag::Script);
@@ skipping 176 matching lines @@
     float specifiedSize = fontDescription.specifiedSize();
 
     if (!specifiedSize && fontDescription.keywordSize())
         specifiedSize = FontSize::fontSizeForKeyword(&m_document, fontDescription.keywordSize(), fontDescription.fixedPitchFontType());
 
     fontDescription.setSpecifiedSize(specifiedSize);
 
     checkForGenericFamilyChange(style.fontDescription(), fontDescription);
 }
 
+void FontBuilder::updateAdjustedSize(FontDescription& fontDescription, const LayoutStyle& style, FontSelector* fontSelector)
+{
+    const float sizeAdjust = fontDescription.sizeAdjust();
+    const float specifiedSize = fontDescription.specifiedSize();
+    if (!sizeAdjust || !specifiedSize)
+        return;
+
+    // We need to create a temporal Font to get xHeight of a primary font.
+    Font font(fontDescription);
+    font.update(fontSelector);
+    if (!font.fontMetrics().hasXHeight())
+        return;
+
+    float aspectValue = font.fontMetrics().xHeight() / specifiedSize;
+    float adjustedSize = (sizeAdjust / aspectValue) * specifiedSize;
+    adjustedSize = getComputedSizeFromSpecifiedSize(fontDescription, style.effectiveZoom(), adjustedSize);
+
+    float multiplier = style.textAutosizingMultiplier();
+    if (multiplier > 1)
+        adjustedSize = TextAutosizer::computeAutosizedFontSize(adjustedSize, multiplier);
+    fontDescription.setAdjustedSize(adjustedSize);
+}
+
 void FontBuilder::updateComputedSize(FontDescription& fontDescription, const LayoutStyle& style)
 {
     float computedSize = getComputedSizeFromSpecifiedSize(fontDescription, style.effectiveZoom(), fontDescription.specifiedSize());
     float multiplier = style.textAutosizingMultiplier();
     if (multiplier > 1)
         computedSize = TextAutosizer::computeAutosizedFontSize(computedSize, multiplier);
     fontDescription.setComputedSize(computedSize);
 }
 
 void FontBuilder::createFont(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, LayoutStyle& style)
 {
     if (!m_flags)
         return;
 
     FontDescription description = style.fontDescription();
 
     if (isSet(PropertySetFlag::Family)) {
         description.setGenericFamily(m_fontDescription.genericFamily());
         description.setFamily(m_fontDescription.family());
     }
     if (isSet(PropertySetFlag::Size)) {
         description.setKeywordSize(m_fontDescription.keywordSize());
         description.setSpecifiedSize(m_fontDescription.specifiedSize());
         description.setIsAbsoluteSize(m_fontDescription.isAbsoluteSize());
     }
+    if (isSet(PropertySetFlag::SizeAdjust))
+        description.setSizeAdjust(m_fontDescription.sizeAdjust());
     if (isSet(PropertySetFlag::Weight))
         description.setWeight(m_fontDescription.weight());
     if (isSet(PropertySetFlag::Stretch))
         description.setStretch(m_fontDescription.stretch());
     if (isSet(PropertySetFlag::FeatureSettings))
         description.setFeatureSettings(m_fontDescription.featureSettings());
     if (isSet(PropertySetFlag::Script)) {
         description.setLocale(m_fontDescription.locale());
         description.setScript(m_fontDescription.script());
     }
     if (isSet(PropertySetFlag::Style))
         description.setStyle(m_fontDescription.style());
     if (isSet(PropertySetFlag::Variant))
         description.setVariant(m_fontDescription.variant());
     if (isSet(PropertySetFlag::VariantLigatures))
         description.setVariantLigatures(m_fontDescription.variantLigatures());
     if (isSet(PropertySetFlag::TextRendering))
         description.setTextRendering(m_fontDescription.textRendering());
     if (isSet(PropertySetFlag::Kerning))
         description.setKerning(m_fontDescription.kerning());
     if (isSet(PropertySetFlag::FontSmoothing))
         description.setFontSmoothing(m_fontDescription.fontSmoothing());
     if (isSet(PropertySetFlag::TextOrientation) || isSet(PropertySetFlag::WritingMode))
         updateOrientation(description, style);
 
     updateSpecifiedSize(description, style);
     updateComputedSize(description, style);
+    updateAdjustedSize(description, style, fontSelector.get());
 
     style.setFontDescription(description);
     style.font().update(fontSelector);
     m_flags = 0;
 }
 
 void FontBuilder::createFontForDocument(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, LayoutStyle& documentStyle)
 {
     FontDescription fontDescription = FontDescription();
     fontDescription.setLocale(documentStyle.locale());
     fontDescription.setScript(localeToScriptCodeForFontSelection(documentStyle.locale()));
 
     setFamilyDescription(fontDescription, FontBuilder::initialFamilyDescription());
     setSize(fontDescription, FontDescription::Size(FontSize::initialKeywordSize(), 0.0f, false));
     updateSpecifiedSize(fontDescription, documentStyle);
     updateComputedSize(fontDescription, documentStyle);
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle.setFontDescription(fontDescription);
     documentStyle.font().update(fontSelector);
 }
 
 }