Cleanup IFDE_CSS interfaces.

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 "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;
@@ skipping 48 matching lines @@
 void CFDE_CSSCounterStyle::UpdateIndex() {
   if (!m_bIndexDirty) {
     return;
   }
   m_arrCounterData.RemoveAll();
   DoUpdateIndex(m_pCounterInc);
   DoUpdateIndex(m_pCounterReset);
   m_bIndexDirty = FALSE;
 }
 
-FDE_CSSRuleData::FDE_CSSRuleData(IFDE_CSSSelector* pSel,
-                                 IFDE_CSSDeclaration* pDecl,
+FDE_CSSRuleData::FDE_CSSRuleData(CFDE_CSSSelector* pSel,
+                                 CFDE_CSSDeclaration* pDecl,
                                  uint32_t dwPos)
     : pSelector(pSel), pDeclaration(pDecl), dwPriority(dwPos), pNext(NULL) {
   static const uint32_t s_Specific[5] = {0x00010000, 0x00010000, 0x00100000,
                                          0x00100000, 0x01000000};
   for (; pSel != NULL; pSel = pSel->GetNextSelector()) {
     FDE_CSSSELECTORTYPE eType = pSel->GetType();
     if (eType > FDE_CSSSELECTORTYPE_Descendant ||
         pSel->GetNameHash() != FDE_CSSUNIVERSALHASH) {
       dwPriority += s_Specific[eType];
     }
@@ skipping 21 matching lines @@
     }
   }
 }
 void CFDE_CSSRuleCollection::AddRulesFrom(IFDE_CSSStyleSheet* pStyleSheet,
                                           IFDE_CSSRule* pRule,
                                           uint32_t dwMediaList,
                                           IFX_FontMgr* pFontMgr) {
   switch (pRule->GetType()) {
     case FDE_CSSRULETYPE_Style: {
       IFDE_CSSStyleRule* pStyleRule = (IFDE_CSSStyleRule*)pRule;
-      IFDE_CSSDeclaration* pDeclaration = pStyleRule->GetDeclaration();
+      CFDE_CSSDeclaration* pDeclaration = pStyleRule->GetDeclaration();
       int32_t iSelectors = pStyleRule->CountSelectorLists();
       for (int32_t i = 0; i < iSelectors; ++i) {
-        IFDE_CSSSelector* pSelector = pStyleRule->GetSelectorList(i);
+        CFDE_CSSSelector* pSelector = pStyleRule->GetSelectorList(i);
         if (pSelector->GetType() == FDE_CSSSELECTORTYPE_Persudo) {
           FDE_CSSRuleData* pData = NewRuleData(pSelector, pDeclaration);
           AddRuleTo(m_pPersudoRules, pData);
           continue;
         }
         if (pSelector->GetNameHash() != FDE_CSSUNIVERSALHASH) {
           AddRuleTo(m_TagRules, pSelector->GetNameHash(), pSelector,
                     pDeclaration);
           continue;
         }
-        IFDE_CSSSelector* pNext = pSelector->GetNextSelector();
-        if (pNext == NULL) {
+        CFDE_CSSSelector* pNext = pSelector->GetNextSelector();
+        if (!pNext) {
           FDE_CSSRuleData* pData = NewRuleData(pSelector, pDeclaration);
           AddRuleTo(m_pUniversalRules, pData);
           continue;
         }
         switch (pNext->GetType()) {
           case FDE_CSSSELECTORTYPE_ID:
             AddRuleTo(m_IDRules, pNext->GetNameHash(), pSelector, pDeclaration);
             break;
           case FDE_CSSSELECTORTYPE_Class:
             AddRuleTo(m_ClassRules, pNext->GetNameHash(), pSelector,
@@ skipping 18 matching lines @@
                        pFontMgr);
         }
       }
     } break;
     default:
       break;
   }
 }
 void CFDE_CSSRuleCollection::AddRuleTo(CFX_MapPtrToPtr& map,
                                        uint32_t dwKey,
-                                       IFDE_CSSSelector* pSel,
-                                       IFDE_CSSDeclaration* pDecl) {
+                                       CFDE_CSSSelector* pSel,
+                                       CFDE_CSSDeclaration* pDecl) {
   void* pKey = (void*)(uintptr_t)dwKey;
   FDE_CSSRuleData* pData = NewRuleData(pSel, pDecl);
   FDE_CSSRuleData* pList = NULL;
   if (!map.Lookup(pKey, (void*&)pList)) {
     map.SetAt(pKey, pData);
   } else if (AddRuleTo(pList, pData)) {
     map.SetAt(pKey, pList);
   }
 }
 
 FX_BOOL CFDE_CSSRuleCollection::AddRuleTo(FDE_CSSRuleData*& pList,
                                           FDE_CSSRuleData* pData) {
   if (pList) {
     pData->pNext = pList->pNext;
     pList->pNext = pData;
     return FALSE;
   }
 
   pList = pData;
   return TRUE;
 }
 
 FDE_CSSRuleData* CFDE_CSSRuleCollection::NewRuleData(
-    IFDE_CSSSelector* pSel,
-    IFDE_CSSDeclaration* pDecl) {
+    CFDE_CSSSelector* pSel,
+    CFDE_CSSDeclaration* pDecl) {
   return FXTARGET_NewWith(m_pStaticStore)
       FDE_CSSRuleData(pSel, pDecl, ++m_iSelectors);
 }
 
-IFDE_CSSStyleSelector* IFDE_CSSStyleSelector::Create() {
-  return new CFDE_CSSStyleSelector;
-}
 CFDE_CSSStyleSelector::CFDE_CSSStyleSelector()
     : m_pFontMgr(NULL),
       m_fDefFontSize(12.0f),
       m_pRuleDataStore(NULL),
       m_pInlineStyleStore(NULL),
       m_pFixedStyleStore(NULL),
       m_pAccelerator(NULL) {
   m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_High] = FDE_CSSSTYLESHEETGROUP_Author;
   m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Mid] = FDE_CSSSTYLESHEETGROUP_User;
   m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Low] =
@@ skipping 138 matching lines @@
                                        FDE_CSSRuleData* pList,
                                        FDE_CSSPERSUDO ePersudoType) {
   while (pList) {
     if (MatchSelector(pCache, pList->pSelector, ePersudoType))
       m_MatchedRules.push_back(pList);
     pList = pList->pNext;
   }
 }
 
 FX_BOOL CFDE_CSSStyleSelector::MatchSelector(FDE_CSSTagCache* pCache,
-                                             IFDE_CSSSelector* pSel,
+                                             CFDE_CSSSelector* pSel,
                                              FDE_CSSPERSUDO ePersudoType) {
   uint32_t dwHash;
   while (pSel != NULL && pCache != NULL) {
     switch (pSel->GetType()) {
       case FDE_CSSSELECTORTYPE_Descendant:
         dwHash = pSel->GetNameHash();
         while ((pCache = pCache->GetParent()) != NULL) {
           if (dwHash != FDE_CSSUNIVERSALHASH && dwHash != pCache->HashTag()) {
             continue;
           }
@@ skipping 30 matching lines @@
         ASSERT(FALSE);
         break;
     }
     pSel = pSel->GetNextSelector();
   }
   return pSel == NULL && pCache != NULL;
 }
 
 void CFDE_CSSStyleSelector::ComputeStyle(
     CXFA_CSSTagProvider* pTag,
-    const IFDE_CSSDeclaration** ppDeclArray,
+    const CFDE_CSSDeclaration** ppDeclArray,
     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)
@@ skipping 17 matching lines @@
         args.pStringCache = nullptr;
         args.pStaticStore = m_pInlineStyleStore;
         args.pProperty = FDE_GetCSSPropertyByEnum(FDE_CSSPROPERTY_TextAlign);
         pDecl->AddProperty(&args, wsValue.c_str(), wsValue.GetLength());
       }
     }
 
     if (pDecl) {
       CFDE_CSSDeclarationArray decls;
       decls.SetSize(iDeclCount + 1);
-      IFDE_CSSDeclaration** ppInline = decls.GetData();
+      CFDE_CSSDeclaration** ppInline = decls.GetData();
       FXSYS_memcpy(ppInline, ppDeclArray,
-                   iDeclCount * sizeof(IFDE_CSSDeclaration*));
+                   iDeclCount * sizeof(CFDE_CSSDeclaration*));
       ppInline[iDeclCount++] = pDecl;
-      ApplyDeclarations(TRUE, (const IFDE_CSSDeclaration**)ppInline, iDeclCount,
-                        pDestStyle);
-      ApplyDeclarations(FALSE, (const IFDE_CSSDeclaration**)ppInline,
+      ApplyDeclarations(TRUE, const_cast<const CFDE_CSSDeclaration**>(ppInline),
+                        iDeclCount, pDestStyle);
+      ApplyDeclarations(FALSE,
+                        const_cast<const CFDE_CSSDeclaration**>(ppInline),
                         iDeclCount, pDestStyle);
       return;
     }
   }
 
   if (iDeclCount > 0) {
     ASSERT(ppDeclArray);
 
     ApplyDeclarations(TRUE, ppDeclArray, iDeclCount, pDestStyle);
     ApplyDeclarations(FALSE, ppDeclArray, iDeclCount, pDestStyle);
   }
 }
 
 void CFDE_CSSStyleSelector::ApplyDeclarations(
     FX_BOOL bPriority,
-    const IFDE_CSSDeclaration** ppDeclArray,
+    const CFDE_CSSDeclaration** ppDeclArray,
     int32_t iDeclCount,
     IFDE_CSSComputedStyle* pDestStyle) {
   CFDE_CSSComputedStyle* pComputedStyle = (CFDE_CSSComputedStyle*)pDestStyle;
   IFDE_CSSValue* pVal;
   FX_BOOL bImportant;
   int32_t i;
   if (bPriority) {
     IFDE_CSSValue *pLastest = NULL, *pImportant = NULL;
     for (i = 0; i < iDeclCount; ++i) {
       pVal = ppDeclArray[i]->GetProperty(FDE_CSSPROPERTY_FontSize, bImportant);
       if (pVal == NULL) {
         continue;
       } else if (bImportant) {
         pImportant = pVal;
       } else {
         pLastest = pVal;
       }
     }
     if (pImportant) {
       ApplyProperty(FDE_CSSPROPERTY_FontSize, pImportant, pComputedStyle);
     } else if (pLastest) {
       ApplyProperty(FDE_CSSPROPERTY_FontSize, pLastest, pComputedStyle);
     }
   } else {
     CFDE_CSSDeclarationArray importants;
-    const IFDE_CSSDeclaration* pDecl = NULL;
+    const CFDE_CSSDeclaration* pDecl = nullptr;
     FDE_CSSPROPERTY eProp;
     FX_POSITION pos;
     for (i = 0; i < iDeclCount; ++i) {
       pDecl = ppDeclArray[i];
       pos = pDecl->GetStartPosition();
       while (pos != NULL) {
         pDecl->GetNextProperty(pos, eProp, pVal, bImportant);
         if (eProp == FDE_CSSPROPERTY_FontSize) {
           continue;
         } else if (!bImportant) {
           ApplyProperty(eProp, pVal, pComputedStyle);
         } else if (importants.GetSize() == 0 ||
                    importants[importants.GetUpperBound()] != pDecl) {
-          importants.Add((IFDE_CSSDeclaration*)pDecl);
+          importants.Add(const_cast<CFDE_CSSDeclaration*>(pDecl));
         }
       }
     }
     iDeclCount = importants.GetSize();
     for (i = 0; i < iDeclCount; ++i) {
       pDecl = importants[i];
       pos = pDecl->GetStartPosition();
       while (pos != NULL) {
         pDecl->GetNextProperty(pos, eProp, pVal, bImportant);
         if (bImportant && eProp != FDE_CSSPROPERTY_FontSize) {
           ApplyProperty(eProp, pVal, pComputedStyle);
         }
       }
     }
     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 != NULL && psz != NULL && iLen > 0);
-  IFDE_CSSSyntaxParser* pSyntax = IFDE_CSSSyntaxParser::Create();
-  if (pSyntax == NULL) {
-    return;
-  }
+  ASSERT(pDecl && psz && iLen > 0);
+
+  CFDE_CSSSyntaxParser* pSyntax = new CFDE_CSSSyntaxParser;
   if (pSyntax->Init(psz, iLen, 32, TRUE)) {
     int32_t iLen;
     const FX_WCHAR* psz;
     FDE_CSSPROPERTYARGS args;
     args.pStringCache = NULL;
     args.pStaticStore = m_pInlineStyleStore;
     args.pProperty = NULL;
     CFX_WideString wsName;
     for (;;) {
       FDE_CSSSYNTAXSTATUS eStatus = pSyntax->DoSyntaxParse();
@@ skipping 1222 matching lines @@
       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;
 }