Split fde/css files into individual class files.

This CL splits the files in xfa/fde/css into class per file and renames any
needed files to match the class names.

Update some of the classes to use std::stack.

Change-Id: I4eca0fb3556d949a15a873bb0f0fd732f47e4fb1
Reviewed-on: https://pdfium-review.googlesource.com/2253
Commit-Queue: dsinclair <dsinclair@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Nicolás Peña <npm@chromium.org>

1 files changed, 662 insertions, 0 deletions

diff --git a/xfa/fde/css/cfde_cssdeclaration.cpp b/xfa/fde/css/cfde_cssdeclaration.cpp
new file mode 100644
index 0000000000..4ed20eb0cc
--- /dev/null
+++ b/xfa/fde/css/cfde_cssdeclaration.cpp
@@ -0,0 +1,662 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "xfa/fde/css/cfde_cssdeclaration.h"
+
+#include "core/fxcrt/fx_ext.h"
+#include "third_party/base/ptr_util.h"
+#include "xfa/fde/css/cfde_csscolorvalue.h"
+#include "xfa/fde/css/cfde_csscustomproperty.h"
+#include "xfa/fde/css/cfde_cssenumvalue.h"
+#include "xfa/fde/css/cfde_cssnumbervalue.h"
+#include "xfa/fde/css/cfde_csspropertyholder.h"
+#include "xfa/fde/css/cfde_cssstringvalue.h"
+#include "xfa/fde/css/cfde_cssvaluelist.h"
+#include "xfa/fde/css/cfde_cssvaluelistparser.h"
+
+namespace {
+
+uint8_t Hex2Dec(uint8_t hexHigh, uint8_t hexLow) {
+  return (FXSYS_toHexDigit(hexHigh) << 4) + FXSYS_toHexDigit(hexLow);
+}
+
+bool ParseCSSNumber(const FX_WCHAR* pszValue,
+                    int32_t iValueLen,
+                    FX_FLOAT& fValue,
+                    FDE_CSSNumberType& eUnit) {
+  ASSERT(pszValue && iValueLen > 0);
+  int32_t iUsedLen = 0;
+  fValue = FXSYS_wcstof(pszValue, iValueLen, &iUsedLen);
+  if (iUsedLen <= 0)
+    return false;
+
+  iValueLen -= iUsedLen;
+  pszValue += iUsedLen;
+  eUnit = FDE_CSSNumberType::Number;
+  if (iValueLen >= 1 && *pszValue == '%') {
+    eUnit = FDE_CSSNumberType::Percent;
+  } else if (iValueLen == 2) {
+    const FDE_CSSLengthUnitTable* pUnit =
+        FDE_GetCSSLengthUnitByName(CFX_WideStringC(pszValue, 2));
+    if (pUnit)
+      eUnit = pUnit->wValue;
+  }
+  return true;
+}
+
+}  // namespace
+
+// static
+bool CFDE_CSSDeclaration::ParseCSSString(const FX_WCHAR* pszValue,
+                                         int32_t iValueLen,
+                                         int32_t* iOffset,
+                                         int32_t* iLength) {
+  ASSERT(pszValue && iValueLen > 0);
+  *iOffset = 0;
+  *iLength = iValueLen;
+  if (iValueLen >= 2) {
+    FX_WCHAR first = pszValue[0], last = pszValue[iValueLen - 1];
+    if ((first == '\"' && last == '\"') || (first == '\'' && last == '\'')) {
+      *iOffset = 1;
+      *iLength -= 2;
+    }
+  }
+  return iValueLen > 0;
+}
+
+// static.
+bool CFDE_CSSDeclaration::ParseCSSColor(const FX_WCHAR* pszValue,
+                                        int32_t iValueLen,
+                                        FX_ARGB* dwColor) {
+  ASSERT(pszValue && iValueLen > 0);
+  ASSERT(dwColor);
+
+  if (*pszValue == '#') {
+    switch (iValueLen) {
+      case 4: {
+        uint8_t red = Hex2Dec((uint8_t)pszValue[1], (uint8_t)pszValue[1]);
+        uint8_t green = Hex2Dec((uint8_t)pszValue[2], (uint8_t)pszValue[2]);
+        uint8_t blue = Hex2Dec((uint8_t)pszValue[3], (uint8_t)pszValue[3]);
+        *dwColor = ArgbEncode(255, red, green, blue);
+        return true;
+      }
+      case 7: {
+        uint8_t red = Hex2Dec((uint8_t)pszValue[1], (uint8_t)pszValue[2]);
+        uint8_t green = Hex2Dec((uint8_t)pszValue[3], (uint8_t)pszValue[4]);
+        uint8_t blue = Hex2Dec((uint8_t)pszValue[5], (uint8_t)pszValue[6]);
+        *dwColor = ArgbEncode(255, red, green, blue);
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+
+  if (iValueLen >= 10) {
+    if (pszValue[iValueLen - 1] != ')' || FXSYS_wcsnicmp(L"rgb(", pszValue, 4))
+      return false;
+
+    uint8_t rgb[3] = {0};
+    FX_FLOAT fValue;
+    FDE_CSSPrimitiveType eType;
+    CFDE_CSSValueListParser list(pszValue + 4, iValueLen - 5, ',');
+    for (int32_t i = 0; i < 3; ++i) {
+      if (!list.NextValue(eType, pszValue, iValueLen))
+        return false;
+      if (eType != FDE_CSSPrimitiveType::Number)
+        return false;
+      FDE_CSSNumberType eNumType;
+      if (!ParseCSSNumber(pszValue, iValueLen, fValue, eNumType))
+        return false;
+
+      rgb[i] = eNumType == FDE_CSSNumberType::Percent
+                   ? FXSYS_round(fValue * 2.55f)
+                   : FXSYS_round(fValue);
+    }
+    *dwColor = ArgbEncode(255, rgb[0], rgb[1], rgb[2]);
+    return true;
+  }
+
+  const FDE_CSSCOLORTABLE* pColor =
+      FDE_GetCSSColorByName(CFX_WideStringC(pszValue, iValueLen));
+  if (!pColor)
+    return false;
+
+  *dwColor = pColor->dwValue;
+  return true;
+}
+
+CFDE_CSSDeclaration::CFDE_CSSDeclaration() {}
+
+CFDE_CSSDeclaration::~CFDE_CSSDeclaration() {}
+
+CFDE_CSSValue* CFDE_CSSDeclaration::GetProperty(FDE_CSSProperty eProperty,
+                                                bool& bImportant) const {
+  for (const auto& p : properties_) {
+    if (p->eProperty == eProperty) {
+      bImportant = p->bImportant;
+      return p->pValue.Get();
+    }
+  }
+  return nullptr;
+}
+
+const FX_WCHAR* CFDE_CSSDeclaration::CopyToLocal(
+    const FDE_CSSPropertyArgs* pArgs,
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen) {
+  ASSERT(iValueLen > 0);
+  std::unordered_map<uint32_t, FX_WCHAR*>* pCache = pArgs->pStringCache;
+  uint32_t key = 0;
+  if (pCache) {
+    key = FX_HashCode_GetW(CFX_WideStringC(pszValue, iValueLen), false);
+    auto it = pCache->find(key);
+    if (it != pCache->end())
+      return it->second;
+  }
+  FX_WCHAR* psz = FX_Alloc(FX_WCHAR, iValueLen + 1);
+  FXSYS_wcsncpy(psz, pszValue, iValueLen);
+  psz[iValueLen] = '\0';
+  if (pCache)
+    (*pCache)[key] = psz;
+
+  return psz;
+}
+
+void CFDE_CSSDeclaration::AddPropertyHolder(FDE_CSSProperty eProperty,
+                                            CFX_RetainPtr<CFDE_CSSValue> pValue,
+                                            bool bImportant) {
+  auto pHolder = pdfium::MakeUnique<CFDE_CSSPropertyHolder>();
+  pHolder->bImportant = bImportant;
+  pHolder->eProperty = eProperty;
+  pHolder->pValue = pValue;
+  properties_.push_back(std::move(pHolder));
+}
+
+void CFDE_CSSDeclaration::AddProperty(const FDE_CSSPropertyArgs* pArgs,
+                                      const FX_WCHAR* pszValue,
+                                      int32_t iValueLen) {
+  ASSERT(iValueLen > 0);
+  bool bImportant = false;
+  if (iValueLen >= 10 && pszValue[iValueLen - 10] == '!' &&
+      FXSYS_wcsnicmp(L"important", pszValue + iValueLen - 9, 9) == 0) {
+    if ((iValueLen -= 10) == 0)
+      return;
+
+    bImportant = true;
+  }
+  const uint32_t dwType = pArgs->pProperty->dwType;
+  switch (dwType & 0x0F) {
+    case FDE_CSSVALUETYPE_Primitive: {
+      static const uint32_t g_ValueGuessOrder[] = {
+          FDE_CSSVALUETYPE_MaybeNumber, FDE_CSSVALUETYPE_MaybeEnum,
+          FDE_CSSVALUETYPE_MaybeColor, FDE_CSSVALUETYPE_MaybeString,
+      };
+      static const int32_t g_ValueGuessCount =
+          sizeof(g_ValueGuessOrder) / sizeof(uint32_t);
+      for (int32_t i = 0; i < g_ValueGuessCount; ++i) {
+        const uint32_t dwMatch = dwType & g_ValueGuessOrder[i];
+        if (dwMatch == 0) {
+          continue;
+        }
+        CFX_RetainPtr<CFDE_CSSValue> pCSSValue;
+        switch (dwMatch) {
+          case FDE_CSSVALUETYPE_MaybeNumber:
+            pCSSValue = ParseNumber(pArgs, pszValue, iValueLen);
+            break;
+          case FDE_CSSVALUETYPE_MaybeEnum:
+            pCSSValue = ParseEnum(pArgs, pszValue, iValueLen);
+            break;
+          case FDE_CSSVALUETYPE_MaybeColor:
+            pCSSValue = ParseColor(pArgs, pszValue, iValueLen);
+            break;
+          case FDE_CSSVALUETYPE_MaybeString:
+            pCSSValue = ParseString(pArgs, pszValue, iValueLen);
+            break;
+          default:
+            break;
+        }
+        if (pCSSValue) {
+          AddPropertyHolder(pArgs->pProperty->eName, pCSSValue, bImportant);
+          return;
+        }
+        if (FDE_IsOnlyValue(dwType, g_ValueGuessOrder[i]))
+          return;
+      }
+      break;
+    }
+    case FDE_CSSVALUETYPE_Shorthand: {
+      CFX_RetainPtr<CFDE_CSSValue> pWidth;
+      switch (pArgs->pProperty->eName) {
+        case FDE_CSSProperty::Font:
+          ParseFontProperty(pArgs, pszValue, iValueLen, bImportant);
+          return;
+        case FDE_CSSProperty::Border:
+          if (ParseBorderProperty(pszValue, iValueLen, pWidth)) {
+            AddPropertyHolder(FDE_CSSProperty::BorderLeftWidth, pWidth,
+                              bImportant);
+            AddPropertyHolder(FDE_CSSProperty::BorderTopWidth, pWidth,
+                              bImportant);
+            AddPropertyHolder(FDE_CSSProperty::BorderRightWidth, pWidth,
+                              bImportant);
+            AddPropertyHolder(FDE_CSSProperty::BorderBottomWidth, pWidth,
+                              bImportant);
+            return;
+          }
+          break;
+        case FDE_CSSProperty::BorderLeft:
+          if (ParseBorderProperty(pszValue, iValueLen, pWidth)) {
+            AddPropertyHolder(FDE_CSSProperty::BorderLeftWidth, pWidth,
+                              bImportant);
+            return;
+          }
+          break;
+        case FDE_CSSProperty::BorderTop:
+          if (ParseBorderProperty(pszValue, iValueLen, pWidth)) {
+            AddPropertyHolder(FDE_CSSProperty::BorderTopWidth, pWidth,
+                              bImportant);
+            return;
+          }
+          break;
+        case FDE_CSSProperty::BorderRight:
+          if (ParseBorderProperty(pszValue, iValueLen, pWidth)) {
+            AddPropertyHolder(FDE_CSSProperty::BorderRightWidth, pWidth,
+                              bImportant);
+            return;
+          }
+          break;
+        case FDE_CSSProperty::BorderBottom:
+          if (ParseBorderProperty(pszValue, iValueLen, pWidth)) {
+            AddPropertyHolder(FDE_CSSProperty::BorderBottomWidth, pWidth,
+                              bImportant);
+            return;
+          }
+          break;
+        default:
+          break;
+      }
+    } break;
+    case FDE_CSSVALUETYPE_List:
+      ParseValueListProperty(pArgs, pszValue, iValueLen, bImportant);
+      return;
+    default:
+      ASSERT(false);
+      break;
+  }
+}
+
+void CFDE_CSSDeclaration::AddProperty(const FDE_CSSPropertyArgs* pArgs,
+                                      const FX_WCHAR* pszName,
+                                      int32_t iNameLen,
+                                      const FX_WCHAR* pszValue,
+                                      int32_t iValueLen) {
+  auto pProperty = pdfium::MakeUnique<CFDE_CSSCustomProperty>();
+  pProperty->pwsName = CopyToLocal(pArgs, pszName, iNameLen);
+  pProperty->pwsValue = CopyToLocal(pArgs, pszValue, iValueLen);
+  custom_properties_.push_back(std::move(pProperty));
+}
+
+CFX_RetainPtr<CFDE_CSSValue> CFDE_CSSDeclaration::ParseNumber(
+    const FDE_CSSPropertyArgs* pArgs,
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen) {
+  FX_FLOAT fValue;
+  FDE_CSSNumberType eUnit;
+  if (!ParseCSSNumber(pszValue, iValueLen, fValue, eUnit))
+    return nullptr;
+  return pdfium::MakeRetain<CFDE_CSSNumberValue>(eUnit, fValue);
+}
+
+CFX_RetainPtr<CFDE_CSSValue> CFDE_CSSDeclaration::ParseEnum(
+    const FDE_CSSPropertyArgs* pArgs,
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen) {
+  const FDE_CSSPropertyValueTable* pValue =
+      FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
+  return pValue ? pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName)
+                : nullptr;
+}
+
+CFX_RetainPtr<CFDE_CSSValue> CFDE_CSSDeclaration::ParseColor(
+    const FDE_CSSPropertyArgs* pArgs,
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen) {
+  FX_ARGB dwColor;
+  if (!ParseCSSColor(pszValue, iValueLen, &dwColor))
+    return nullptr;
+  return pdfium::MakeRetain<CFDE_CSSColorValue>(dwColor);
+}
+
+CFX_RetainPtr<CFDE_CSSValue> CFDE_CSSDeclaration::ParseString(
+    const FDE_CSSPropertyArgs* pArgs,
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen) {
+  int32_t iOffset;
+  if (!ParseCSSString(pszValue, iValueLen, &iOffset, &iValueLen))
+    return nullptr;
+
+  if (iValueLen <= 0)
+    return nullptr;
+
+  pszValue = CopyToLocal(pArgs, pszValue + iOffset, iValueLen);
+  return pszValue ? pdfium::MakeRetain<CFDE_CSSStringValue>(pszValue) : nullptr;
+}
+
+void CFDE_CSSDeclaration::ParseValueListProperty(
+    const FDE_CSSPropertyArgs* pArgs,
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen,
+    bool bImportant) {
+  FX_WCHAR separator =
+      (pArgs->pProperty->eName == FDE_CSSProperty::FontFamily) ? ',' : ' ';
+  CFDE_CSSValueListParser parser(pszValue, iValueLen, separator);
+
+  const uint32_t dwType = pArgs->pProperty->dwType;
+  FDE_CSSPrimitiveType eType;
+  std::vector<CFX_RetainPtr<CFDE_CSSValue>> list;
+  while (parser.NextValue(eType, pszValue, iValueLen)) {
+    switch (eType) {
+      case FDE_CSSPrimitiveType::Number:
+        if (dwType & FDE_CSSVALUETYPE_MaybeNumber) {
+          FX_FLOAT fValue;
+          FDE_CSSNumberType eNumType;
+          if (ParseCSSNumber(pszValue, iValueLen, fValue, eNumType))
+            list.push_back(
+                pdfium::MakeRetain<CFDE_CSSNumberValue>(eNumType, fValue));
+        }
+        break;
+      case FDE_CSSPrimitiveType::String:
+        if (dwType & FDE_CSSVALUETYPE_MaybeColor) {
+          FX_ARGB dwColor;
+          if (ParseCSSColor(pszValue, iValueLen, &dwColor)) {
+            list.push_back(pdfium::MakeRetain<CFDE_CSSColorValue>(dwColor));
+            continue;
+          }
+        }
+        if (dwType & FDE_CSSVALUETYPE_MaybeEnum) {
+          const FDE_CSSPropertyValueTable* pValue =
+              FDE_GetCSSPropertyValueByName(
+                  CFX_WideStringC(pszValue, iValueLen));
+          if (pValue) {
+            list.push_back(
+                pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName));
+            continue;
+          }
+        }
+        if (dwType & FDE_CSSVALUETYPE_MaybeString) {
+          pszValue = CopyToLocal(pArgs, pszValue, iValueLen);
+          list.push_back(pdfium::MakeRetain<CFDE_CSSStringValue>(pszValue));
+        }
+        break;
+      case FDE_CSSPrimitiveType::RGB:
+        if (dwType & FDE_CSSVALUETYPE_MaybeColor) {
+          FX_ARGB dwColor;
+          if (ParseCSSColor(pszValue, iValueLen, &dwColor)) {
+            list.push_back(pdfium::MakeRetain<CFDE_CSSColorValue>(dwColor));
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  if (list.empty())
+    return;
+
+  switch (pArgs->pProperty->eName) {
+    case FDE_CSSProperty::BorderWidth:
+      Add4ValuesProperty(list, bImportant, FDE_CSSProperty::BorderLeftWidth,
+                         FDE_CSSProperty::BorderTopWidth,
+                         FDE_CSSProperty::BorderRightWidth,
+                         FDE_CSSProperty::BorderBottomWidth);
+      return;
+    case FDE_CSSProperty::Margin:
+      Add4ValuesProperty(list, bImportant, FDE_CSSProperty::MarginLeft,
+                         FDE_CSSProperty::MarginTop,
+                         FDE_CSSProperty::MarginRight,
+                         FDE_CSSProperty::MarginBottom);
+      return;
+    case FDE_CSSProperty::Padding:
+      Add4ValuesProperty(list, bImportant, FDE_CSSProperty::PaddingLeft,
+                         FDE_CSSProperty::PaddingTop,
+                         FDE_CSSProperty::PaddingRight,
+                         FDE_CSSProperty::PaddingBottom);
+      return;
+    default: {
+      auto pList = pdfium::MakeRetain<CFDE_CSSValueList>(list);
+      AddPropertyHolder(pArgs->pProperty->eName, pList, bImportant);
+      return;
+    }
+  }
+}
+
+void CFDE_CSSDeclaration::Add4ValuesProperty(
+    const std::vector<CFX_RetainPtr<CFDE_CSSValue>>& list,
+    bool bImportant,
+    FDE_CSSProperty eLeft,
+    FDE_CSSProperty eTop,
+    FDE_CSSProperty eRight,
+    FDE_CSSProperty eBottom) {
+  switch (list.size()) {
+    case 1:
+      AddPropertyHolder(eLeft, list[0], bImportant);
+      AddPropertyHolder(eTop, list[0], bImportant);
+      AddPropertyHolder(eRight, list[0], bImportant);
+      AddPropertyHolder(eBottom, list[0], bImportant);
+      return;
+    case 2:
+      AddPropertyHolder(eLeft, list[1], bImportant);
+      AddPropertyHolder(eTop, list[0], bImportant);
+      AddPropertyHolder(eRight, list[1], bImportant);
+      AddPropertyHolder(eBottom, list[0], bImportant);
+      return;
+    case 3:
+      AddPropertyHolder(eLeft, list[1], bImportant);
+      AddPropertyHolder(eTop, list[0], bImportant);
+      AddPropertyHolder(eRight, list[1], bImportant);
+      AddPropertyHolder(eBottom, list[2], bImportant);
+      return;
+    case 4:
+      AddPropertyHolder(eLeft, list[3], bImportant);
+      AddPropertyHolder(eTop, list[0], bImportant);
+      AddPropertyHolder(eRight, list[1], bImportant);
+      AddPropertyHolder(eBottom, list[2], bImportant);
+      return;
+    default:
+      break;
+  }
+}
+
+bool CFDE_CSSDeclaration::ParseBorderProperty(
+    const FX_WCHAR* pszValue,
+    int32_t iValueLen,
+    CFX_RetainPtr<CFDE_CSSValue>& pWidth) const {
+  pWidth.Reset(nullptr);
+
+  CFDE_CSSValueListParser parser(pszValue, iValueLen, ' ');
+  FDE_CSSPrimitiveType eType;
+  while (parser.NextValue(eType, pszValue, iValueLen)) {
+    switch (eType) {
+      case FDE_CSSPrimitiveType::Number: {
+        if (pWidth)
+          continue;
+
+        FX_FLOAT fValue;
+        FDE_CSSNumberType eNumType;
+        if (ParseCSSNumber(pszValue, iValueLen, fValue, eNumType))
+          pWidth = pdfium::MakeRetain<CFDE_CSSNumberValue>(eNumType, fValue);
+        break;
+      }
+      case FDE_CSSPrimitiveType::String: {
+        const FDE_CSSCOLORTABLE* pColorItem =
+            FDE_GetCSSColorByName(CFX_WideStringC(pszValue, iValueLen));
+        if (pColorItem)
+          continue;
+
+        const FDE_CSSPropertyValueTable* pValue =
+            FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
+        if (!pValue)
+          continue;
+
+        switch (pValue->eName) {
+          case FDE_CSSPropertyValue::Thin:
+          case FDE_CSSPropertyValue::Thick:
+          case FDE_CSSPropertyValue::Medium:
+            if (!pWidth)
+              pWidth = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+            break;
+          default:
+            break;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  if (!pWidth)
+    pWidth = pdfium::MakeRetain<CFDE_CSSNumberValue>(FDE_CSSNumberType::Number,
+                                                     0.0f);
+
+  return true;
+}
+
+void CFDE_CSSDeclaration::ParseFontProperty(const FDE_CSSPropertyArgs* pArgs,
+                                            const FX_WCHAR* pszValue,
+                                            int32_t iValueLen,
+                                            bool bImportant) {
+  CFDE_CSSValueListParser parser(pszValue, iValueLen, '/');
+  CFX_RetainPtr<CFDE_CSSValue> pStyle;
+  CFX_RetainPtr<CFDE_CSSValue> pVariant;
+  CFX_RetainPtr<CFDE_CSSValue> pWeight;
+  CFX_RetainPtr<CFDE_CSSValue> pFontSize;
+  CFX_RetainPtr<CFDE_CSSValue> pLineHeight;
+  std::vector<CFX_RetainPtr<CFDE_CSSValue>> familyList;
+  FDE_CSSPrimitiveType eType;
+  while (parser.NextValue(eType, pszValue, iValueLen)) {
+    switch (eType) {
+      case FDE_CSSPrimitiveType::String: {
+        const FDE_CSSPropertyValueTable* pValue =
+            FDE_GetCSSPropertyValueByName(CFX_WideStringC(pszValue, iValueLen));
+        if (pValue) {
+          switch (pValue->eName) {
+            case FDE_CSSPropertyValue::XxSmall:
+            case FDE_CSSPropertyValue::XSmall:
+            case FDE_CSSPropertyValue::Small:
+            case FDE_CSSPropertyValue::Medium:
+            case FDE_CSSPropertyValue::Large:
+            case FDE_CSSPropertyValue::XLarge:
+            case FDE_CSSPropertyValue::XxLarge:
+            case FDE_CSSPropertyValue::Smaller:
+            case FDE_CSSPropertyValue::Larger:
+              if (!pFontSize)
+                pFontSize =
+                    pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              continue;
+            case FDE_CSSPropertyValue::Bold:
+            case FDE_CSSPropertyValue::Bolder:
+            case FDE_CSSPropertyValue::Lighter:
+              if (!pWeight)
+                pWeight = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              continue;
+            case FDE_CSSPropertyValue::Italic:
+            case FDE_CSSPropertyValue::Oblique:
+              if (!pStyle)
+                pStyle = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              continue;
+            case FDE_CSSPropertyValue::SmallCaps:
+              if (!pVariant)
+                pVariant = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              continue;
+            case FDE_CSSPropertyValue::Normal:
+              if (!pStyle)
+                pStyle = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              else if (!pVariant)
+                pVariant = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              else if (!pWeight)
+                pWeight = pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              else if (!pFontSize)
+                pFontSize =
+                    pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              else if (!pLineHeight)
+                pLineHeight =
+                    pdfium::MakeRetain<CFDE_CSSEnumValue>(pValue->eName);
+              continue;
+            default:
+              break;
+          }
+        }
+        if (pFontSize) {
+          familyList.push_back(pdfium::MakeRetain<CFDE_CSSStringValue>(
+              CopyToLocal(pArgs, pszValue, iValueLen)));
+        }
+        parser.m_Separator = ',';
+        break;
+      }
+      case FDE_CSSPrimitiveType::Number: {
+        FX_FLOAT fValue;
+        FDE_CSSNumberType eNumType;
+        if (!ParseCSSNumber(pszValue, iValueLen, fValue, eNumType))
+          break;
+        if (eType == FDE_CSSPrimitiveType::Number) {
+          switch ((int32_t)fValue) {
+            case 100:
+            case 200:
+            case 300:
+            case 400:
+            case 500:
+            case 600:
+            case 700:
+            case 800:
+            case 900:
+              if (!pWeight)
+                pWeight = pdfium::MakeRetain<CFDE_CSSNumberValue>(
+                    FDE_CSSNumberType::Number, fValue);
+              continue;
+          }
+        }
+        if (!pFontSize)
+          pFontSize = pdfium::MakeRetain<CFDE_CSSNumberValue>(eNumType, fValue);
+        else if (!pLineHeight)
+          pLineHeight =
+              pdfium::MakeRetain<CFDE_CSSNumberValue>(eNumType, fValue);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  if (!pStyle)
+    pStyle =
+        pdfium::MakeRetain<CFDE_CSSEnumValue>(FDE_CSSPropertyValue::Normal);
+  if (!pVariant)
+    pVariant =
+        pdfium::MakeRetain<CFDE_CSSEnumValue>(FDE_CSSPropertyValue::Normal);
+  if (!pWeight)
+    pWeight =
+        pdfium::MakeRetain<CFDE_CSSEnumValue>(FDE_CSSPropertyValue::Normal);
+  if (!pFontSize)
+    pFontSize =
+        pdfium::MakeRetain<CFDE_CSSEnumValue>(FDE_CSSPropertyValue::Medium);
+  if (!pLineHeight)
+    pLineHeight =
+        pdfium::MakeRetain<CFDE_CSSEnumValue>(FDE_CSSPropertyValue::Normal);
+
+  AddPropertyHolder(FDE_CSSProperty::FontStyle, pStyle, bImportant);
+  AddPropertyHolder(FDE_CSSProperty::FontVariant, pVariant, bImportant);
+  AddPropertyHolder(FDE_CSSProperty::FontWeight, pWeight, bImportant);
+  AddPropertyHolder(FDE_CSSProperty::FontSize, pFontSize, bImportant);
+  AddPropertyHolder(FDE_CSSProperty::LineHeight, pLineHeight, bImportant);
+  if (!familyList.empty()) {
+    auto pList = pdfium::MakeRetain<CFDE_CSSValueList>(familyList);
+    AddPropertyHolder(FDE_CSSProperty::FontFamily, pList, bImportant);
+  }
+}
+
+size_t CFDE_CSSDeclaration::PropertyCountForTesting() const {
+  return properties_.size();
+}