Implement font-variant-numeric

third_party/WebKit/Source/platform/fonts/FontDescription.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  *
  * 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
@@ skipping 15 matching lines @@
 #define FontDescription_h
 
 #include "SkFontStyle.h"
 #include "platform/FontFamilyNames.h"
 #include "platform/fonts/FontCacheKey.h"
 #include "platform/fonts/FontFamily.h"
 #include "platform/fonts/FontFeatureSettings.h"
 #include "platform/fonts/FontOrientation.h"
 #include "platform/fonts/FontSmoothingMode.h"
 #include "platform/fonts/FontTraits.h"
+#include "platform/fonts/FontVariantNumeric.h"
 #include "platform/fonts/FontWidthVariant.h"
 #include "platform/fonts/TextRenderingMode.h"
 #include "platform/fonts/TypesettingFeatures.h"
 #include "platform/text/LocaleToScriptMapping.h"
 #include "wtf/Allocator.h"
 #include "wtf/MathExtras.h"
 
 #include "wtf/RefPtr.h"
 
 #include <unicode/uscript.h>
 
 namespace blink {
 
 const float FontSizeAdjustNone = -1;
+typedef struct {
+    uint32_t f[2];

[eae, 2016/05/09 16:31:58]

part or segment might be a better name than f. None of them area great though.
Perhaps using a 64bit int instead would be better?

[drott, 2016/05/10 10:59:06]

Renamed to 'parts' to indicate it's an array.

+} FieldsAsUnsignedType;
 
 class PLATFORM_EXPORT FontDescription {
     USING_FAST_MALLOC(FontDescription);
 public:
     enum GenericFamilyType { NoFamily, StandardFamily, SerifFamily, SansSerifFamily,
                              MonospaceFamily, CursiveFamily, FantasyFamily, PictographFamily };
 
     enum Kerning { AutoKerning, NormalKerning, NoneKerning };
 
     enum LigaturesState { NormalLigaturesState, DisabledLigaturesState, EnabledLigaturesState };
 
     enum FontVariantCaps { CapsNormal, SmallCaps, AllSmallCaps, PetiteCaps, AllPetiteCaps, Unicase, TitlingCaps };
 
     FontDescription()
         : m_specifiedSize(0)
         , m_computedSize(0)
         , m_adjustedSize(0)
         , m_sizeAdjust(FontSizeAdjustNone)
         , m_letterSpacing(0)
         , m_wordSpacing(0)
     {
-        m_fieldsAsUnsigned[0] = 0;
-        m_fieldsAsUnsigned[1] = 0;
+        m_fieldsAsUnsigned.f[0] = 0;
+        m_fieldsAsUnsigned.f[1] = 0;
         m_fields.m_orientation = static_cast<unsigned>(FontOrientation::Horizontal);
         m_fields.m_widthVariant = RegularWidth;
         m_fields.m_style = FontStyleNormal;
         m_fields.m_variantCaps = CapsNormal;
         m_fields.m_isAbsoluteSize = false;
         m_fields.m_weight = FontWeightNormal;
         m_fields.m_stretch = FontStretchNormal;
         m_fields.m_genericFamily = NoFamily;
         m_fields.m_kerning = AutoKerning;
         m_fields.m_commonLigaturesState = NormalLigaturesState;
         m_fields.m_discretionaryLigaturesState = NormalLigaturesState;
         m_fields.m_historicalLigaturesState = NormalLigaturesState;
         m_fields.m_contextualLigaturesState = NormalLigaturesState;
         m_fields.m_keywordSize = 0;
         m_fields.m_fontSmoothing = AutoSmoothing;
         m_fields.m_textRendering = AutoTextRendering;
         m_fields.m_script = USCRIPT_COMMON;
         m_fields.m_syntheticBold = false;
         m_fields.m_syntheticItalic = false;
         m_fields.m_subpixelTextPosition = s_useSubpixelTextPositioning;
         m_fields.m_typesettingFeatures = s_defaultTypesettingFeatures;
+        m_fields.m_variantNumeric = FontVariantNumeric().m_fieldsAsUnsigned;
     }
 
     bool operator==(const FontDescription&) const;
     bool operator!=(const FontDescription& other) const { return !(*this == other); }
 
     struct VariantLigatures {
         STACK_ALLOCATED();
         VariantLigatures(LigaturesState state = NormalLigaturesState)
             : common(state)
             , discretionary(state)
@@ skipping 54 matching lines @@
     static Size smallerSize(const Size&);
     GenericFamilyType genericFamily() const { return static_cast<GenericFamilyType>(m_fields.m_genericFamily); }
 
     // only use fixed default size when there is only one font family, and that family is "monospace"
     bool isMonospace() const
     {
         return genericFamily() == MonospaceFamily && !family().next() && family().family() == FontFamilyNames::webkit_monospace;
     }
     Kerning getKerning() const { return static_cast<Kerning>(m_fields.m_kerning); }
     VariantLigatures getVariantLigatures() const;
+    FontVariantNumeric variantNumeric() const  { return FontVariantNumeric::initializeFromUnsigned(m_fields.m_variantNumeric); };
     LigaturesState commonLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_commonLigaturesState); }
     LigaturesState discretionaryLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_discretionaryLigaturesState); }
     LigaturesState historicalLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_historicalLigaturesState); }
     LigaturesState contextualLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_contextualLigaturesState); }
     unsigned keywordSize() const { return m_fields.m_keywordSize; }
     FontSmoothingMode fontSmoothing() const { return static_cast<FontSmoothingMode>(m_fields.m_fontSmoothing); }
     TextRenderingMode textRendering() const { return static_cast<TextRenderingMode>(m_fields.m_textRendering); }
     UScriptCode script() const { return static_cast<UScriptCode>(m_fields.m_script); }
     const AtomicString& locale(bool includeDefault = true) const;
     bool isSyntheticBold() const { return m_fields.m_syntheticBold; }
@@ skipping 15 matching lines @@
     FontCacheKey cacheKey(const FontFaceCreationParams&, FontTraits desiredTraits = FontTraits(0)) const;
 
     void setFamily(const FontFamily& family) { m_familyList = family; }
     void setComputedSize(float s) { m_computedSize = clampTo<float>(s); }
     void setSpecifiedSize(float s) { m_specifiedSize = clampTo<float>(s); }
     void setAdjustedSize(float s) { m_adjustedSize = clampTo<float>(s); }
     void setSizeAdjust(float aspect) { m_sizeAdjust = clampTo<float>(aspect); }
     void setStyle(FontStyle i) { m_fields.m_style = i; }
     void setVariantCaps(FontVariantCaps variantCaps) { m_fields.m_variantCaps = variantCaps; }
     void setVariantLigatures(const VariantLigatures&);
+    void setVariantNumeric(const FontVariantNumeric&);
     void setIsAbsoluteSize(bool s) { m_fields.m_isAbsoluteSize = s; }
     void setWeight(FontWeight w) { m_fields.m_weight = w; }
     void setStretch(FontStretch s) { m_fields.m_stretch = s; }
     void setGenericFamily(GenericFamilyType genericFamily) { m_fields.m_genericFamily = genericFamily; }
     void setKerning(Kerning kerning) { m_fields.m_kerning = kerning; updateTypesettingFeatures(); }
     void setKeywordSize(unsigned s) { m_fields.m_keywordSize = s; }
     void setFontSmoothing(FontSmoothingMode smoothing) { m_fields.m_fontSmoothing = smoothing; }
     void setTextRendering(TextRenderingMode rendering) { m_fields.m_textRendering = rendering; updateTypesettingFeatures(); }
     void setOrientation(FontOrientation orientation) { m_fields.m_orientation = static_cast<unsigned>(orientation); }
     void setWidthVariant(FontWidthVariant widthVariant) { m_fields.m_widthVariant = widthVariant; }
@@ skipping 11 matching lines @@
 
     TypesettingFeatures getTypesettingFeatures() const { return static_cast<TypesettingFeatures>(m_fields.m_typesettingFeatures); }
 
     static void setSubpixelPositioning(bool b) { s_useSubpixelTextPositioning = b; }
     static bool subpixelPositioning() { return s_useSubpixelTextPositioning; }
 
     static void setDefaultTypesettingFeatures(TypesettingFeatures);
     static TypesettingFeatures defaultTypesettingFeatures();
 
     unsigned styleHashWithoutFamilyList() const;
-    unsigned bitmapFields() const { return m_fieldsAsUnsigned[0]; }
-    unsigned auxiliaryBitmapFields() const { return m_fieldsAsUnsigned[1]; }
+    // FIXME: We should not expose internal structure here, but rather introduce
+    // a hash function here.
+    unsigned bitmapFields() const { return m_fieldsAsUnsigned.f[0]; }
+    unsigned auxiliaryBitmapFields() const { return m_fieldsAsUnsigned.f[1]; }
 
     SkFontStyle skiaFontStyle() const;
 
 private:
     FontFamily m_familyList; // The list of font families to be used.
     RefPtr<FontFeatureSettings> m_featureSettings;
     AtomicString m_locale;
 
     void updateTypesettingFeatures();
 
@@ skipping 37 matching lines @@
         // then we can accurately translate across different generic families to adjust for different preference settings
         // (e.g., 13px monospace vs. 16px everything else).  Sizes are 1-8 (like the HTML size values for <font>).
 
         unsigned m_fontSmoothing : 2; // FontSmoothingMode
         unsigned m_textRendering : 2; // TextRenderingMode
         unsigned m_script : 7; // Used to help choose an appropriate font for generic font families.
         unsigned m_syntheticBold : 1;
         unsigned m_syntheticItalic : 1;
         unsigned m_subpixelTextPosition : 1;
         unsigned m_typesettingFeatures : 2; // TypesettingFeatures
+        unsigned m_variantNumeric : 8;
     };
+
+    static_assert(sizeof(BitFields) == sizeof(FieldsAsUnsignedType),
+        "Mapped bitfield datatypes must have identical size.");
     union {
         BitFields m_fields;
-        uint32_t m_fieldsAsUnsigned[2];
+        FieldsAsUnsignedType m_fieldsAsUnsigned;
     };
 
     static TypesettingFeatures s_defaultTypesettingFeatures;
 
     static bool s_useSubpixelTextPositioning;
 };
 
 inline bool FontDescription::operator==(const FontDescription& other) const
 {
     return m_familyList == other.m_familyList
         && m_locale == other.m_locale
         && m_specifiedSize == other.m_specifiedSize
         && m_computedSize == other.m_computedSize
         && m_adjustedSize == other.m_adjustedSize
         && m_sizeAdjust == other.m_sizeAdjust
         && m_letterSpacing == other.m_letterSpacing
         && m_wordSpacing == other.m_wordSpacing
-        && m_fieldsAsUnsigned[0] == other.m_fieldsAsUnsigned[0]
-        && m_fieldsAsUnsigned[1] == other.m_fieldsAsUnsigned[1]
+        && m_fieldsAsUnsigned.f[0] == other.m_fieldsAsUnsigned.f[0]
+        && m_fieldsAsUnsigned.f[1] == other.m_fieldsAsUnsigned.f[1]
         && (m_featureSettings == other.m_featureSettings || (m_featureSettings && other.m_featureSettings && *m_featureSettings == *other.m_featureSettings));
 }
 
 } // namespace blink
 
 #endif