Use smart pointers for class owned pointers under xfa/fde

xfa/fde/css/fde_cssstyleselector.cpp

 // 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/fde_cssstyleselector.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "xfa/fde/css/fde_csscache.h"
 #include "xfa/fde/css/fde_cssdeclaration.h"
 #include "xfa/fde/css/fde_cssstylesheet.h"
 #include "xfa/fde/css/fde_csssyntax.h"
 #include "xfa/fxfa/app/xfa_textlayout.h"
 
 #define FDE_CSSUNIVERSALHASH ('*')
 
 int32_t CFDE_CSSCounterStyle::FindIndex(const FX_WCHAR* pszIdentifier) {
   int32_t iCount = m_arrCounterData.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     if (FXSYS_wcscmp(pszIdentifier, m_arrCounterData.ElementAt(i).m_pszIdent) ==
         0) {
       return i;
     }
   }
   return -1;
 }
+
 void CFDE_CSSCounterStyle::DoUpdateIndex(IFDE_CSSValueList* pList) {
   if (!pList)
     return;
 
   int32_t iCount = pList->CountValues();
   FX_FLOAT fDefValue = 1.0;
   FX_BOOL bDefIncrement = TRUE;
   if (pList == m_pCounterReset) {
     fDefValue = 0.0;
     bDefIncrement = FALSE;
@@ skipping 59 matching lines @@
   for (; pSel; pSel = pSel->GetNextSelector()) {
     FDE_CSSSELECTORTYPE eType = pSel->GetType();
     if (eType > FDE_CSSSELECTORTYPE_Descendant ||
         pSel->GetNameHash() != FDE_CSSUNIVERSALHASH) {
       dwPriority += s_Specific[eType];
     }
   }
 }
 
 CFDE_CSSStyleSelector::CFDE_CSSStyleSelector()
-    : m_pFontMgr(nullptr),
-      m_fDefFontSize(12.0f),
-      m_pRuleDataStore(nullptr),
-      m_pInlineStyleStore(nullptr),
-      m_pFixedStyleStore(nullptr),
-      m_pAccelerator(nullptr) {
+    : m_pFontMgr(nullptr), m_fDefFontSize(12.0f) {
   m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_High] = FDE_CSSSTYLESHEETGROUP_Author;
   m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Mid] = FDE_CSSSTYLESHEETGROUP_User;
   m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Low] =
       FDE_CSSSTYLESHEETGROUP_UserAgent;
 }
 
 CFDE_CSSStyleSelector::~CFDE_CSSStyleSelector() {
   Reset();
-  delete m_pInlineStyleStore;
-  delete m_pFixedStyleStore;
-  delete m_pAccelerator;
 }
 
 void CFDE_CSSStyleSelector::SetFontMgr(IFGAS_FontMgr* pFontMgr) {

[Lei Zhang, 2016/08/04 18:09:15]

This is called right after creation. Merge into the ctor and make |m_pFontMgr| a
const pointer?

[Wei Li, 2016/08/04 21:42:25]

Done.

   m_pFontMgr = pFontMgr;
 }
+
 void CFDE_CSSStyleSelector::SetDefFontSize(FX_FLOAT fFontSize) {
   ASSERT(fFontSize > 0);
   m_fDefFontSize = fFontSize;
 }
 
 CFDE_CSSAccelerator* CFDE_CSSStyleSelector::InitAccelerator() {
   if (!m_pAccelerator)
-    m_pAccelerator = new CFDE_CSSAccelerator;
+    m_pAccelerator.reset(new CFDE_CSSAccelerator);
   m_pAccelerator->Clear();
-  return m_pAccelerator;
+  return m_pAccelerator.get();
 }
 
 IFDE_CSSComputedStyle* CFDE_CSSStyleSelector::CreateComputedStyle(
     IFDE_CSSComputedStyle* pParentStyle) {
   if (!m_pFixedStyleStore) {
-    m_pFixedStyleStore = IFX_MemoryAllocator::Create(
-        FX_ALLOCTYPE_Fixed, 16, sizeof(CFDE_CSSComputedStyle));
+    m_pFixedStyleStore.reset(IFX_MemoryAllocator::Create(
+        FX_ALLOCTYPE_Fixed, 16, sizeof(CFDE_CSSComputedStyle)));
   }
-  CFDE_CSSComputedStyle* pStyle = FXTARGET_NewWith(m_pFixedStyleStore)
-      CFDE_CSSComputedStyle(m_pFixedStyleStore);
+  CFDE_CSSComputedStyle* pStyle = FXTARGET_NewWith(m_pFixedStyleStore.get())
+      CFDE_CSSComputedStyle(m_pFixedStyleStore.get());
   if (pParentStyle) {
     pStyle->m_InheritedData =
         static_cast<CFDE_CSSComputedStyle*>(pParentStyle)->m_InheritedData;
   } else {
     pStyle->m_InheritedData.Reset();
   }
   pStyle->m_NonInheritedData.Reset();
   return pStyle;
 }
+
 FX_BOOL CFDE_CSSStyleSelector::SetStyleSheet(FDE_CSSSTYLESHEETGROUP eType,
                                              IFDE_CSSStyleSheet* pSheet) {
   ASSERT(eType < FDE_CSSSTYLESHEETGROUP_MAX);
   CFDE_CSSStyleSheetArray& dest = m_SheetGroups[eType];
   dest.RemoveAt(0, dest.GetSize());
   if (pSheet)
     dest.Add(pSheet);
   return TRUE;
 }
+
 FX_BOOL CFDE_CSSStyleSelector::SetStyleSheets(
     FDE_CSSSTYLESHEETGROUP eType,
     const CFDE_CSSStyleSheetArray* pArray) {
   ASSERT(eType < FDE_CSSSTYLESHEETGROUP_MAX);
   CFDE_CSSStyleSheetArray& dest = m_SheetGroups[eType];
   if (pArray)
     dest.Copy(*pArray);
   else
     dest.RemoveAt(0, dest.GetSize());
   return TRUE;
 }
+
 void CFDE_CSSStyleSelector::SetStylePriority(
     FDE_CSSSTYLESHEETGROUP eType,
     FDE_CSSSTYLESHEETPRIORITY ePriority) {
   m_ePriorities[ePriority] = eType;
 }
+
 void CFDE_CSSStyleSelector::UpdateStyleIndex(uint32_t dwMediaList) {
   Reset();
-  m_pRuleDataStore = IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 1024, 0);
+  m_pRuleDataStore.reset(
+      IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 1024, 0));
   for (int32_t iGroup = 0; iGroup < FDE_CSSSTYLESHEETGROUP_MAX; ++iGroup) {
     CFDE_CSSRuleCollection& rules = m_RuleCollection[iGroup];
-    rules.m_pStaticStore = m_pRuleDataStore;
+    rules.m_pStaticStore = m_pRuleDataStore.get();
     rules.AddRulesFrom(m_SheetGroups[iGroup], dwMediaList, m_pFontMgr);
   }
 }
+
 void CFDE_CSSStyleSelector::Reset() {
   for (int32_t iGroup = 0; iGroup < FDE_CSSSTYLESHEETGROUP_MAX; ++iGroup) {
     m_RuleCollection[iGroup].Clear();
   }
-  delete m_pRuleDataStore;
-  m_pRuleDataStore = nullptr;
+  m_pRuleDataStore.reset();
 }
+
 int32_t CFDE_CSSStyleSelector::MatchDeclarations(
     CXFA_CSSTagProvider* pTag,
     CFDE_CSSDeclarationArray& matchedDecls,
     FDE_CSSPERSUDO ePersudoType) {
   ASSERT(m_pAccelerator && pTag);
 
   FDE_CSSTagCache* pCache = m_pAccelerator->GetTopElement();
   ASSERT(pCache && pCache->GetTag() == pTag);
 
   matchedDecls.RemoveAt(0, matchedDecls.GetSize());
@@ skipping 97 matching lines @@
     int32_t iDeclCount,
     IFDE_CSSComputedStyle* pDestStyle) {
   ASSERT(iDeclCount >= 0);
   ASSERT(pDestStyle);
 
   static const uint32_t s_dwStyleHash = FX_HashCode_GetW(L"style", true);
   static const uint32_t s_dwAlignHash = FX_HashCode_GetW(L"align", true);
 
   if (!pTag->empty()) {
     if (!m_pInlineStyleStore) {
-      m_pInlineStyleStore =
-          IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 2048, 0);
+      m_pInlineStyleStore.reset(
+          IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 2048, 0));
     }
     CFDE_CSSDeclaration* pDecl = nullptr;
     for (auto it : *pTag) {
       CFX_WideString wsAttri = it.first;
       CFX_WideString wsValue = it.second;
       uint32_t dwAttriHash = FX_HashCode_GetW(wsAttri.AsStringC(), true);
       if (dwAttriHash == s_dwStyleHash) {
         if (!pDecl)
-          pDecl = FXTARGET_NewWith(m_pInlineStyleStore) CFDE_CSSDeclaration;
+          pDecl =
+              FXTARGET_NewWith(m_pInlineStyleStore.get()) CFDE_CSSDeclaration;
 
         AppendInlineStyle(pDecl, wsValue.c_str(), wsValue.GetLength());
       } else if (dwAttriHash == s_dwAlignHash) {
         if (!pDecl)
-          pDecl = FXTARGET_NewWith(m_pInlineStyleStore) CFDE_CSSDeclaration;
+          pDecl =
+              FXTARGET_NewWith(m_pInlineStyleStore.get()) CFDE_CSSDeclaration;
 
         FDE_CSSPROPERTYARGS args;
         args.pStringCache = nullptr;
-        args.pStaticStore = m_pInlineStyleStore;
+        args.pStaticStore = m_pInlineStyleStore.get();
         args.pProperty = FDE_GetCSSPropertyByEnum(FDE_CSSPROPERTY_TextAlign);
         pDecl->AddProperty(&args, wsValue.c_str(), wsValue.GetLength());
       }
     }
 
     if (pDecl) {
       CFDE_CSSDeclarationArray decls;
       decls.SetSize(iDeclCount + 1);
       CFDE_CSSDeclaration** ppInline = decls.GetData();
       FXSYS_memcpy(ppInline, ppDeclArray,
@@ skipping 76 matching lines @@
       }
     }
     CFX_WideString wsName, wsValue;
     pos = pDecl->GetStartCustom();
     while (pos) {
       pDecl->GetNextCustom(pos, wsName, wsValue);
       pComputedStyle->AddCustomStyle(wsName, wsValue);
     }
   }
 }
+
 void CFDE_CSSStyleSelector::AppendInlineStyle(CFDE_CSSDeclaration* pDecl,
                                               const FX_WCHAR* psz,
                                               int32_t iLen) {
   ASSERT(pDecl && psz && iLen > 0);
   std::unique_ptr<CFDE_CSSSyntaxParser> pSyntax(new CFDE_CSSSyntaxParser);
   if (!pSyntax->Init(psz, iLen, 32, TRUE))
     return;
 
   int32_t iLen2 = 0;
   const FX_WCHAR* psz2;
   FDE_CSSPROPERTYARGS args;
   args.pStringCache = nullptr;
-  args.pStaticStore = m_pInlineStyleStore;
+  args.pStaticStore = m_pInlineStyleStore.get();
   args.pProperty = nullptr;
   CFX_WideString wsName;
   while (1) {
     FDE_CSSSYNTAXSTATUS eStatus = pSyntax->DoSyntaxParse();
     if (eStatus == FDE_CSSSYNTAXSTATUS_PropertyName) {
       psz2 = pSyntax->GetCurrentString(iLen2);
       args.pProperty = FDE_GetCSSPropertyByName(CFX_WideStringC(psz2, iLen2));
       if (!args.pProperty)
         wsName = CFX_WideStringC(psz2, iLen2);
     } else if (eStatus == FDE_CSSSYNTAXSTATUS_PropertyValue) {
@@ skipping 552 matching lines @@
           }
         } break;
         default:
           break;
       }
     }
   } else {
     ASSERT(FALSE);
   }
 }
+
 FX_FLOAT CFDE_CSSStyleSelector::ApplyNumber(FDE_CSSPRIMITIVETYPE eUnit,
                                             FX_FLOAT fValue,
                                             FX_FLOAT fPercentBase) {
   switch (eUnit) {
     case FDE_CSSPRIMITIVETYPE_PX:
     case FDE_CSSPRIMITIVETYPE_Number:
       return fValue * 72 / 96;
     case FDE_CSSPRIMITIVETYPE_PT:
       return fValue;
     case FDE_CSSPRIMITIVETYPE_EMS:
     case FDE_CSSPRIMITIVETYPE_EXS:
       return fValue * fPercentBase;
     case FDE_CSSPRIMITIVETYPE_Percent:
       return fValue * fPercentBase / 100.0f;
     case FDE_CSSPRIMITIVETYPE_CM:
       return fValue * 28.3464f;
     case FDE_CSSPRIMITIVETYPE_MM:
       return fValue * 2.8346f;
     case FDE_CSSPRIMITIVETYPE_IN:
       return fValue * 72.0f;
     case FDE_CSSPRIMITIVETYPE_PC:
       return fValue / 12.0f;
     default:
       return fValue;
   }
 }
+
 FDE_CSSRUBYSPAN CFDE_CSSStyleSelector::ToRubySpan(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_None:
     default:
       return FDE_CSSRUBYSPAN_None;
   }
 }
+
 FDE_CSSRUBYPOSITION CFDE_CSSStyleSelector::ToRubyPosition(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Before:
       return FDE_CSSRUBYPOSITION_Before;
     case FDE_CSSPROPERTYVALUE_After:
       return FDE_CSSRUBYPOSITION_After;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSRUBYPOSITION_Right;
     case FDE_CSSPROPERTYVALUE_Inline:
       return FDE_CSSRUBYPOSITION_Inline;
     default:
       return FDE_CSSRUBYPOSITION_Before;
   }
 }
+
 FDE_CSSRUBYOVERHANG CFDE_CSSStyleSelector::ToRubyOverhang(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Auto:
       return FDE_CSSRUBYOVERHANG_Auto;
     case FDE_CSSPROPERTYVALUE_Start:
       return FDE_CSSRUBYOVERHANG_Start;
     case FDE_CSSPROPERTYVALUE_End:
       return FDE_CSSRUBYOVERHANG_End;
     case FDE_CSSPROPERTYVALUE_None:
     default:
       return FDE_CSSRUBYOVERHANG_None;
   }
 }
+
 FDE_CSSRUBYALIGN CFDE_CSSStyleSelector::ToRubyAlign(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Auto:
       return FDE_CSSRUBYALIGN_Auto;
     case FDE_CSSPROPERTYVALUE_Start:
       return FDE_CSSRUBYALIGN_Start;
     case FDE_CSSPROPERTYVALUE_Left:
       return FDE_CSSRUBYALIGN_End;
     case FDE_CSSPROPERTYVALUE_Center:
       return FDE_CSSRUBYALIGN_Center;
     case FDE_CSSPROPERTYVALUE_End:
       return FDE_CSSRUBYALIGN_End;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSRUBYALIGN_Right;
     case FDE_CSSPROPERTYVALUE_DistributeLetter:
       return FDE_CSSRUBYALIGN_DistributeLetter;
     case FDE_CSSPROPERTYVALUE_DistributeSpace:
       return FDE_CSSRUBYALIGN_DistributeSpace;
     case FDE_CSSPROPERTYVALUE_LineEdge:
       return FDE_CSSRUBYALIGN_LineEdge;
     default:
       return FDE_CSSRUBYALIGN_Auto;
   }
 }
+
 FX_BOOL CFDE_CSSStyleSelector::ToTextEmphasisMark(
     FDE_CSSPROPERTYVALUE eValue,
     FDE_CSSTEXTEMPHASISMARK& eMark) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_None:
       eMark = FDE_CSSTEXTEMPHASISMARK_None;
       return TRUE;
     case FDE_CSSPROPERTYVALUE_Dot:
       eMark = FDE_CSSTEXTEMPHASISMARK_Dot;
       return TRUE;
     case FDE_CSSPROPERTYVALUE_Circle:
       eMark = FDE_CSSTEXTEMPHASISMARK_Circle;
       return TRUE;
     case FDE_CSSPROPERTYVALUE_DoubleCircle:
       eMark = FDE_CSSTEXTEMPHASISMARK_DoubleCircle;
       return TRUE;
     case FDE_CSSPROPERTYVALUE_Triangle:
       eMark = FDE_CSSTEXTEMPHASISMARK_Triangle;
       return TRUE;
     case FDE_CSSPROPERTYVALUE_Sesame:
       eMark = FDE_CSSTEXTEMPHASISMARK_Sesame;
       return TRUE;
     default:
       return FALSE;
   }
 }
+
 FX_BOOL CFDE_CSSStyleSelector::ToTextEmphasisFill(
     FDE_CSSPROPERTYVALUE eValue,
     FDE_CSSTEXTEMPHASISFILL& eFill) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Filled:
       eFill = FDE_CSSTEXTEMPHASISFILL_Filled;
       return TRUE;
     case FDE_CSSPROPERTYVALUE_Open:
       eFill = FDE_CSSTEXTEMPHASISFILL_Open;
       return TRUE;
     default:
       return FALSE;
   }
 }
+
 FDE_CSSBKGATTACHMENT CFDE_CSSStyleSelector::ToBKGAttachment(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Fixed:
       return FDE_CSSBKGATTACHMENT_Fixed;
     case FDE_CSSPROPERTYVALUE_Scroll:
       return FDE_CSSBKGATTACHMENT_Scroll;
     default:
       return FDE_CSSBKGATTACHMENT_Fixed;
   }
 }
+
 FDE_CSSCAPTIONSIDE CFDE_CSSStyleSelector::ToCaptionSide(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Top:
       return FDE_CSSCAPTIONSIDE_Top;
     case FDE_CSSPROPERTYVALUE_Bottom:
       return FDE_CSSCAPTIONSIDE_Bottom;
     case FDE_CSSPROPERTYVALUE_Left:
       return FDE_CSSCAPTIONSIDE_Left;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSCAPTIONSIDE_Right;
     case FDE_CSSPROPERTYVALUE_Before:
       return FDE_CSSCAPTIONSIDE_Before;
     case FDE_CSSPROPERTYVALUE_After:
       return FDE_CSSCAPTIONSIDE_After;
     default:
       return FDE_CSSCAPTIONSIDE_Top;
   }
 }
+
 FDE_CSSPOSITION CFDE_CSSStyleSelector::ToPosition(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Static:
       return FDE_CSSPOSITION_Static;
     case FDE_CSSPROPERTYVALUE_Relative:
       return FDE_CSSPOSITION_Relative;
     case FDE_CSSPROPERTYVALUE_Fixed:
       return FDE_CSSPOSITION_Fixed;
     case FDE_CSSPROPERTYVALUE_Absolute:
       return FDE_CSSPOSITION_Absolute;
     default:
       return FDE_CSSPOSITION_Static;
   }
 }
+
 FDE_CSSCURSOR CFDE_CSSStyleSelector::ToCursor(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Auto:
       return FDE_CSSCURSOR_Auto;
     case FDE_CSSPROPERTYVALUE_Crosshair:
       return FDE_CSSCURSOR_Crosshair;
     case FDE_CSSPROPERTYVALUE_Default:
       return FDE_CSSCURSOR_Default;
     case FDE_CSSPROPERTYVALUE_Pointer:
       return FDE_CSSCURSOR_Pointer;
     case FDE_CSSPROPERTYVALUE_Move:
       return FDE_CSSCURSOR_Move;
     case FDE_CSSPROPERTYVALUE_EResize:
       return FDE_CSSCURSOR_EResize;
     case FDE_CSSPROPERTYVALUE_NeResize:
       return FDE_CSSCURSOR_NeResize;
     case FDE_CSSPROPERTYVALUE_NwResize:
       return FDE_CSSCURSOR_NwResize;
     case FDE_CSSPROPERTYVALUE_NResize:
       return FDE_CSSCURSOR_NResize;
     case FDE_CSSPROPERTYVALUE_SeResize:
       return FDE_CSSCURSOR_SeResize;
     case FDE_CSSPROPERTYVALUE_SwResize:
       return FDE_CSSCURSOR_SwResize;
     default:
       return FDE_CSSCURSOR_Auto;
   }
 }
+
 FDE_CSSBKGREPEAT CFDE_CSSStyleSelector::ToBKGRepeat(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Repeat:
       return FDE_CSSBKGREPEAT_Repeat;
     case FDE_CSSPROPERTYVALUE_RepeatX:
       return FDE_CSSBKGREPEAT_RepeatX;
     case FDE_CSSPROPERTYVALUE_RepeatY:
       return FDE_CSSBKGREPEAT_RepeatY;
     case FDE_CSSPROPERTYVALUE_NoRepeat:
       return FDE_CSSBKGREPEAT_NoRepeat;
     default:
       return FDE_CSSBKGREPEAT_Repeat;
   }
 }
+
 FDE_CSSTEXTCOMBINE CFDE_CSSStyleSelector::ToTextCombine(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Horizontal:
       return FDE_CSSTEXTCOMBINE_Horizontal;
     case FDE_CSSPROPERTYVALUE_None:
     default:
       return FDE_CSSTEXTCOMBINE_None;
   }
 }
+
 FDE_CSSLINEBREAK CFDE_CSSStyleSelector::ToLineBreak(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Auto:
       return FDE_CSSLINEBREAK_Auto;
     case FDE_CSSPROPERTYVALUE_Loose:
       return FDE_CSSLINEBREAK_Loose;
     case FDE_CSSPROPERTYVALUE_Normal:
       return FDE_CSSLINEBREAK_Normal;
     case FDE_CSSPROPERTYVALUE_Strict:
       return FDE_CSSLINEBREAK_Strict;
     default:
       return FDE_CSSLINEBREAK_Auto;
   }
 }
+
 FDE_CSSOVERFLOW CFDE_CSSStyleSelector::ToOverflow(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Visible:
       return FDE_CSSOVERFLOW_Visible;
     case FDE_CSSPROPERTYVALUE_Hidden:
       return FDE_CSSOVERFLOW_Hidden;
     case FDE_CSSPROPERTYVALUE_Scroll:
       return FDE_CSSOVERFLOW_Scroll;
     case FDE_CSSPROPERTYVALUE_Auto:
       return FDE_CSSOVERFLOW_Auto;
     case FDE_CSSPROPERTYVALUE_NoDisplay:
       return FDE_CSSOVERFLOW_NoDisplay;
     case FDE_CSSPROPERTYVALUE_NoContent:
       return FDE_CSSOVERFLOW_NoContent;
     default:
       return FDE_CSSOVERFLOW_Visible;
   }
 }
+
 FDE_CSSWRITINGMODE CFDE_CSSStyleSelector::ToWritingMode(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_HorizontalTb:
       return FDE_CSSWRITINGMODE_HorizontalTb;
     case FDE_CSSPROPERTYVALUE_VerticalRl:
       return FDE_CSSWRITINGMODE_VerticalRl;
     case FDE_CSSPROPERTYVALUE_VerticalLr:
       return FDE_CSSWRITINGMODE_VerticalLr;
     default:
       return FDE_CSSWRITINGMODE_HorizontalTb;
   }
 }
+
 FDE_CSSWORDBREAK CFDE_CSSStyleSelector::ToWordBreak(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Normal:
       return FDE_CSSWORDBREAK_Normal;
     case FDE_CSSPROPERTYVALUE_KeepAll:
       return FDE_CSSWORDBREAK_KeepAll;
     case FDE_CSSPROPERTYVALUE_BreakAll:
       return FDE_CSSWORDBREAK_BreakAll;
     case FDE_CSSPROPERTYVALUE_KeepWords:
       return FDE_CSSWORDBREAK_KeepWords;
     default:
       return FDE_CSSWORDBREAK_Normal;
   }
 }
+
 FDE_CSSFLOAT CFDE_CSSStyleSelector::ToFloat(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Left:
       return FDE_CSSFLOAT_Left;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSFLOAT_Right;
     case FDE_CSSPROPERTYVALUE_None:
       return FDE_CSSFLOAT_None;
     default:
       return FDE_CSSFLOAT_None;
   }
 }
+
 FDE_CSSCLEAR CFDE_CSSStyleSelector::ToClear(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_None:
       return FDE_CSSCLEAR_None;
     case FDE_CSSPROPERTYVALUE_Left:
       return FDE_CSSCLEAR_Left;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSCLEAR_Right;
     case FDE_CSSPROPERTYVALUE_Both:
       return FDE_CSSCLEAR_Both;
     default:
       return FDE_CSSCLEAR_None;
   }
 }
+
 FDE_CSSPAGEBREAK CFDE_CSSStyleSelector::ToPageBreak(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Avoid:
       return FDE_CSSPAGEBREAK_Avoid;
     case FDE_CSSPROPERTYVALUE_Auto:
       return FDE_CSSPAGEBREAK_Auto;
     case FDE_CSSPROPERTYVALUE_Always:
       return FDE_CSSPAGEBREAK_Always;
     case FDE_CSSPROPERTYVALUE_Left:
       return FDE_CSSPAGEBREAK_Left;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSPAGEBREAK_Right;
     default:
       return FDE_CSSPAGEBREAK_Auto;
   }
 }
+
 FDE_CSSDISPLAY CFDE_CSSStyleSelector::ToDisplay(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Inline:
       return FDE_CSSDISPLAY_Inline;
     case FDE_CSSPROPERTYVALUE_Block:
       return FDE_CSSDISPLAY_Block;
     case FDE_CSSPROPERTYVALUE_None:
       return FDE_CSSDISPLAY_None;
     case FDE_CSSPROPERTYVALUE_ListItem:
       return FDE_CSSDISPLAY_ListItem;
@@ skipping 28 matching lines @@
     case FDE_CSSPROPERTYVALUE_RubyText:
       return FDE_CSSDISPLAY_RubyText;
     case FDE_CSSPROPERTYVALUE_RubyBaseGroup:
       return FDE_CSSDISPLSY_RubyBaseGroup;
     case FDE_CSSPROPERTYVALUE_RubyTextGroup:
       return FDE_CSSDISPLAY_RubyTextGroup;
     default:
       return FDE_CSSDISPLAY_Inline;
   }
 }
+
 FDE_CSSTEXTALIGN CFDE_CSSStyleSelector::ToTextAlign(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Left:
       return FDE_CSSTEXTALIGN_Left;
     case FDE_CSSPROPERTYVALUE_Center:
       return FDE_CSSTEXTALIGN_Center;
     case FDE_CSSPROPERTYVALUE_Right:
       return FDE_CSSTEXTALIGN_Right;
     case FDE_CSSPROPERTYVALUE_Justify:
       return FDE_CSSTEXTALIGN_Justify;
     default:
       return FDE_CSSTEXTALIGN_Left;
   }
 }
+
 uint16_t CFDE_CSSStyleSelector::ToFontWeight(FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Normal:
       return 400;
     case FDE_CSSPROPERTYVALUE_Bold:
       return 700;
     case FDE_CSSPROPERTYVALUE_Bolder:
       return 900;
     case FDE_CSSPROPERTYVALUE_Lighter:
       return 200;
     default:
       return 400;
   }
 }
+
 FDE_CSSFONTSTYLE CFDE_CSSStyleSelector::ToFontStyle(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Italic:
     case FDE_CSSPROPERTYVALUE_Oblique:
       return FDE_CSSFONTSTYLE_Italic;
     default:
       return FDE_CSSFONTSTYLE_Normal;
   }
 }
+
 FDE_CSSBORDERSTYLE CFDE_CSSStyleSelector::ToBorderStyle(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_None:
       return FDE_CSSBORDERSTYLE_None;
     case FDE_CSSPROPERTYVALUE_Solid:
       return FDE_CSSBORDERSTYLE_Solid;
     case FDE_CSSPROPERTYVALUE_Hidden:
       return FDE_CSSBORDERSTYLE_Hidden;
     case FDE_CSSPROPERTYVALUE_Dotted:
       return FDE_CSSBORDERSTYLE_Dotted;
     case FDE_CSSPROPERTYVALUE_Dashed:
       return FDE_CSSBORDERSTYLE_Dashed;
     case FDE_CSSPROPERTYVALUE_Double:
       return FDE_CSSBORDERSTYLE_Double;
     case FDE_CSSPROPERTYVALUE_Groove:
       return FDE_CSSBORDERSTYLE_Groove;
     case FDE_CSSPROPERTYVALUE_Ridge:
       return FDE_CSSBORDERSTYLE_Ridge;
     case FDE_CSSPROPERTYVALUE_Inset:
       return FDE_CSSBORDERSTYLE_Inset;
     case FDE_CSSPROPERTYVALUE_Outset:
       return FDE_CSSBORDERSTYLE_outset;
     default:
       return FDE_CSSBORDERSTYLE_None;
   }
 }
+
 FX_BOOL CFDE_CSSStyleSelector::SetLengthWithPercent(
     FDE_CSSLENGTH& width,
     FDE_CSSPRIMITIVETYPE eType,
     IFDE_CSSPrimitiveValue* pPrimitive,
     FX_FLOAT fFontSize) {
   if (eType == FDE_CSSPRIMITIVETYPE_Percent) {
     width.Set(FDE_CSSLENGTHUNIT_Percent, pPrimitive->GetFloat() / 100.0f);
     return width.NonZero();
   } else if (eType >= FDE_CSSPRIMITIVETYPE_Number &&
              eType <= FDE_CSSPRIMITIVETYPE_PC) {
@@ skipping 16 matching lines @@
         return TRUE;
       case FDE_CSSPROPERTYVALUE_Thick:
         width.Set(FDE_CSSLENGTHUNIT_Point, 4);
         return TRUE;
       default:
         return FALSE;
     }
   }
   return FALSE;
 }
+
 FX_FLOAT CFDE_CSSStyleSelector::ToFontSize(FDE_CSSPROPERTYVALUE eValue,
                                            FX_FLOAT fCurFontSize) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_XxSmall:
       return m_fDefFontSize / 1.2f / 1.2f / 1.2f;
     case FDE_CSSPROPERTYVALUE_XSmall:
       return m_fDefFontSize / 1.2f / 1.2f;
     case FDE_CSSPROPERTYVALUE_Small:
       return m_fDefFontSize / 1.2f;
     case FDE_CSSPROPERTYVALUE_Medium:
       return m_fDefFontSize;
     case FDE_CSSPROPERTYVALUE_Large:
       return m_fDefFontSize * 1.2f;
     case FDE_CSSPROPERTYVALUE_XLarge:
       return m_fDefFontSize * 1.2f * 1.2f;
     case FDE_CSSPROPERTYVALUE_XxLarge:
       return m_fDefFontSize * 1.2f * 1.2f * 1.2f;
     case FDE_CSSPROPERTYVALUE_Larger:
       return fCurFontSize * 1.2f;
     case FDE_CSSPROPERTYVALUE_Smaller:
       return fCurFontSize / 1.2f;
     default:
       return fCurFontSize;
   }
 }
+
 FDE_CSSVERTICALALIGN CFDE_CSSStyleSelector::ToVerticalAlign(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Baseline:
       return FDE_CSSVERTICALALIGN_Baseline;
     case FDE_CSSPROPERTYVALUE_Middle:
       return FDE_CSSVERTICALALIGN_Middle;
     case FDE_CSSPROPERTYVALUE_Bottom:
       return FDE_CSSVERTICALALIGN_Bottom;
     case FDE_CSSPROPERTYVALUE_Super:
       return FDE_CSSVERTICALALIGN_Super;
     case FDE_CSSPROPERTYVALUE_Sub:
       return FDE_CSSVERTICALALIGN_Sub;
     case FDE_CSSPROPERTYVALUE_Top:
       return FDE_CSSVERTICALALIGN_Top;
     case FDE_CSSPROPERTYVALUE_TextTop:
       return FDE_CSSVERTICALALIGN_TextTop;
     case FDE_CSSPROPERTYVALUE_TextBottom:
       return FDE_CSSVERTICALALIGN_TextBottom;
     default:
       return FDE_CSSVERTICALALIGN_Baseline;
   }
 }
+
 FDE_CSSLISTSTYLETYPE CFDE_CSSStyleSelector::ToListStyleType(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_None:
       return FDE_CSSLISTSTYLETYPE_None;
     case FDE_CSSPROPERTYVALUE_Disc:
       return FDE_CSSLISTSTYLETYPE_Disc;
     case FDE_CSSPROPERTYVALUE_Circle:
       return FDE_CSSLISTSTYLETYPE_Circle;
     case FDE_CSSPROPERTYVALUE_Square:
@@ skipping 29 matching lines @@
     case FDE_CSSLISTSTYLETYPE_HiraganaIroha:
       return FDE_CSSLISTSTYLETYPE_HiraganaIroha;
     case FDE_CSSLISTSTYLETYPE_Katakana:
       return FDE_CSSLISTSTYLETYPE_Katakana;
     case FDE_CSSLISTSTYLETYPE_KatakanaIroha:
       return FDE_CSSLISTSTYLETYPE_KatakanaIroha;
     default:
       return FDE_CSSLISTSTYLETYPE_Disc;
   }
 }
+
 FDE_CSSLISTSTYLEPOSITION CFDE_CSSStyleSelector::ToListStylePosition(
     FDE_CSSPROPERTYVALUE eValue) {
   return eValue == FDE_CSSPROPERTYVALUE_Inside
              ? FDE_CSSLISTSTYLEPOSITION_Inside
              : FDE_CSSLISTSTYLEPOSITION_Outside;
 }
+
 FDE_CSSVISIBILITY CFDE_CSSStyleSelector::ToVisibility(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Visible:
       return FDE_CSSVISIBILITY_Visible;
     case FDE_CSSPROPERTYVALUE_Hidden:
       return FDE_CSSVISIBILITY_Hidden;
     case FDE_CSSPROPERTYVALUE_Collapse:
       return FDE_CSSVISIBILITY_Collapse;
     default:
       return FDE_CSSVISIBILITY_Visible;
   }
 }
+
 FDE_CSSWHITESPACE CFDE_CSSStyleSelector::ToWhiteSpace(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_Normal:
       return FDE_CSSWHITESPACE_Normal;
     case FDE_CSSPROPERTYVALUE_Pre:
       return FDE_CSSWHITESPACE_Pre;
     case FDE_CSSPROPERTYVALUE_Nowrap:
       return FDE_CSSWHITESPACE_Nowrap;
     case FDE_CSSPROPERTYVALUE_PreWrap:
       return FDE_CSSWHITESPACE_PreWrap;
     case FDE_CSSPROPERTYVALUE_PreLine:
       return FDE_CSSWHITESPACE_PreLine;
     default:
       return FDE_CSSWHITESPACE_Normal;
   }
 }
+
 uint32_t CFDE_CSSStyleSelector::ToTextDecoration(IFDE_CSSValueList* pValue) {
   uint32_t dwDecoration = 0;
   for (int32_t i = pValue->CountValues() - 1; i >= 0; --i) {
     IFDE_CSSPrimitiveValue* pPrimitive =
         static_cast<IFDE_CSSPrimitiveValue*>(pValue->GetValue(i));
     if (pPrimitive->GetPrimitiveType() == FDE_CSSPRIMITIVETYPE_Enum) {
       switch (pPrimitive->GetEnum()) {
         case FDE_CSSPROPERTYVALUE_Underline:
           dwDecoration |= FDE_CSSTEXTDECORATION_Underline;
           break;
         case FDE_CSSPROPERTYVALUE_LineThrough:
           dwDecoration |= FDE_CSSTEXTDECORATION_LineThrough;
           break;
         case FDE_CSSPROPERTYVALUE_Overline:
           dwDecoration |= FDE_CSSTEXTDECORATION_Overline;
           break;
         case FDE_CSSPROPERTYVALUE_Blink:
           dwDecoration |= FDE_CSSTEXTDECORATION_Blink;
           break;
         case FDE_CSSPROPERTYVALUE_Double:
           dwDecoration |= FDE_CSSTEXTDECORATION_Double;
           break;
         default:
           break;
       }
     }
   }
   return dwDecoration;
 }
+
 FDE_CSSTEXTTRANSFORM CFDE_CSSStyleSelector::ToTextTransform(
     FDE_CSSPROPERTYVALUE eValue) {
   switch (eValue) {
     case FDE_CSSPROPERTYVALUE_None:
       return FDE_CSSTEXTTRANSFORM_None;
     case FDE_CSSPROPERTYVALUE_Capitalize:
       return FDE_CSSTEXTTRANSFORM_Capitalize;
     case FDE_CSSPROPERTYVALUE_Uppercase:
       return FDE_CSSTEXTTRANSFORM_UpperCase;
     case FDE_CSSPROPERTYVALUE_Lowercase:
       return FDE_CSSTEXTTRANSFORM_LowerCase;
     default:
       return FDE_CSSTEXTTRANSFORM_None;
   }
 }
+
 FDE_CSSFONTVARIANT CFDE_CSSStyleSelector::ToFontVariant(
     FDE_CSSPROPERTYVALUE eValue) {
   return eValue == FDE_CSSPROPERTYVALUE_SmallCaps ? FDE_CSSFONTVARIANT_SmallCaps
                                                   : FDE_CSSFONTVARIANT_Normal;
 }
 
 CFDE_CSSComputedStyle::CFDE_CSSComputedStyle(IFX_MemoryAllocator* pAlloc)
     : m_dwRefCount(1), m_pAllocator(pAlloc) {}
 
 CFDE_CSSComputedStyle::~CFDE_CSSComputedStyle() {}
@@ skipping 215 matching lines @@
   m_MaxBoxSize.Set(FDE_CSSLENGTHUNIT_None);
   m_eDisplay = FDE_CSSDISPLAY_Inline;
   m_fVerticalAlign = 0.0f;
   m_ColumnCount.Set(FDE_CSSLENGTHUNIT_Auto);
   m_ColumnGap.Set(FDE_CSSLENGTHUNIT_Normal);
   m_bColumnRuleColorSame = TRUE;
   m_ColumnWidth.Set(FDE_CSSLENGTHUNIT_Auto);
   m_ColumnRuleWidth.Set(FDE_CSSLENGTHUNIT_Auto);
   m_eTextCombine = FDE_CSSTEXTCOMBINE_None;
 }