Remove FX_DWORD from XFA.

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>
 
@@ skipping 67 matching lines @@
   if (m_InheritedData.m_eTextEmphasisMark != FDE_CSSTEXTEMPHASISMARK_Auto) {
     return (FDE_CSSTEXTEMPHASISMARK)m_InheritedData.m_eTextEmphasisMark;
   }
   if (m_InheritedData.m_eWritingMode == FDE_CSSWRITINGMODE_HorizontalTb) {
     return FDE_CSSTEXTEMPHASISMARK_Dot;
   }
   return FDE_CSSTEXTEMPHASISMARK_Sesame;
 }
 FDE_CSSRuleData::FDE_CSSRuleData(IFDE_CSSSelector* pSel,
                                  IFDE_CSSDeclaration* pDecl,
-                                 FX_DWORD dwPos)
+                                 uint32_t dwPos)
     : pSelector(pSel), pDeclaration(pDecl), dwPriority(dwPos), pNext(NULL) {
-  static const FX_DWORD s_Specific[5] = {0x00010000, 0x00010000, 0x00100000,
+  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];
     }
   }
 }
 void CFDE_CSSRuleCollection::Clear() {
   m_IDRules.RemoveAll();
   m_TagRules.RemoveAll();
   m_ClassRules.RemoveAll();
   m_pUniversalRules = NULL;
   m_pStaticStore = NULL;
   m_iSelectors = 0;
 }
 void CFDE_CSSRuleCollection::AddRulesFrom(const CFDE_CSSStyleSheetArray& sheets,
-                                          FX_DWORD dwMediaList,
+                                          uint32_t dwMediaList,
                                           IFX_FontMgr* pFontMgr) {
   int32_t iSheets = sheets.GetSize();
   for (int32_t i = 0; i < iSheets; ++i) {
     IFDE_CSSStyleSheet* pSheet = sheets.GetAt(i);
-    if (FX_DWORD dwMatchMedia = pSheet->GetMediaList() & dwMediaList) {
+    if (uint32_t dwMatchMedia = pSheet->GetMediaList() & dwMediaList) {
       int32_t iRules = pSheet->CountRules();
       for (int32_t j = 0; j < iRules; j++) {
         AddRulesFrom(pSheet, pSheet->GetRule(j), dwMatchMedia, pFontMgr);
       }
     }
   }
 }
 void CFDE_CSSRuleCollection::AddRulesFrom(IFDE_CSSStyleSheet* pStyleSheet,
                                           IFDE_CSSRule* pRule,
-                                          FX_DWORD dwMediaList,
+                                          uint32_t dwMediaList,
                                           IFX_FontMgr* pFontMgr) {
   switch (pRule->GetType()) {
     case FDE_CSSRULETYPE_Style: {
       IFDE_CSSStyleRule* pStyleRule = (IFDE_CSSStyleRule*)pRule;
       IFDE_CSSDeclaration* pDeclaration = pStyleRule->GetDeclaration();
       int32_t iSelectors = pStyleRule->CountSelectorLists();
       for (int32_t i = 0; i < iSelectors; ++i) {
         IFDE_CSSSelector* pSelector = pStyleRule->GetSelectorList(i);
         if (pSelector->GetType() == FDE_CSSSELECTORTYPE_Persudo) {
           FDE_CSSRuleData* pData = NewRuleData(pSelector, pDeclaration);
@@ skipping 37 matching lines @@
           AddRulesFrom(pStyleSheet, pMediaRule->GetRule(i), dwMediaList,
                        pFontMgr);
         }
       }
     } break;
     default:
       break;
   }
 }
 void CFDE_CSSRuleCollection::AddRuleTo(CFX_MapPtrToPtr& map,
-                                       FX_DWORD dwKey,
+                                       uint32_t dwKey,
                                        IFDE_CSSSelector* pSel,
                                        IFDE_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);
   }
@@ skipping 98 matching lines @@
   } else {
     dest.Copy(*pArray);
   }
   return TRUE;
 }
 void CFDE_CSSStyleSelector::SetStylePriority(
     FDE_CSSSTYLESHEETGROUP eType,
     FDE_CSSSTYLESHEETPRIORITY ePriority) {
   m_ePriorities[ePriority] = eType;
 }
-void CFDE_CSSStyleSelector::UpdateStyleIndex(FX_DWORD dwMediaList) {
+void CFDE_CSSStyleSelector::UpdateStyleIndex(uint32_t dwMediaList) {
   Reset();
   m_pRuleDataStore = FX_CreateAllocator(FX_ALLOCTYPE_Static, 1024, 0);
   FXSYS_assert(m_pRuleDataStore != NULL);
   for (int32_t iGroup = 0; iGroup < FDE_CSSSTYLESHEETGROUP_MAX; ++iGroup) {
     CFDE_CSSRuleCollection& rules = m_RuleCollection[iGroup];
     rules.m_pStaticStore = m_pRuleDataStore;
     rules.AddRulesFrom(m_SheetGroups[iGroup], dwMediaList, m_pFontMgr);
   }
 }
 void CFDE_CSSStyleSelector::Reset() {
@@ skipping 53 matching lines @@
   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,
                                              FDE_CSSPERSUDO ePersudoType) {
-  FX_DWORD dwHash;
+  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;
           }
           if (MatchSelector(pCache, pSel->GetNextSelector(), ePersudoType)) {
             return TRUE;
@@ skipping 40 matching lines @@
     IFDE_CSSComputedStyle* pDestStyle) {
   FXSYS_assert(iDeclCount >= 0);
   FXSYS_assert(pDestStyle);
   FX_POSITION pos = pTag->GetFirstAttribute();
   if (pos != NULL) {
     if (m_pInlineStyleStore == NULL) {
       m_pInlineStyleStore = FX_CreateAllocator(FX_ALLOCTYPE_Static, 2048, 0);
     }
     CFDE_CSSDeclaration* pDecl = NULL;
     CFX_WideStringC wsAttri, wsValue;
-    FX_DWORD dwAttriHash;
+    uint32_t dwAttriHash;
     do {
       pTag->GetNextAttribute(pos, wsAttri, wsValue);
       dwAttriHash =
           FX_HashCode_String_GetW(wsAttri.GetPtr(), wsAttri.GetLength(), TRUE);
-      static const FX_DWORD s_dwStyleHash =
+      static const uint32_t s_dwStyleHash =
           FX_HashCode_String_GetW(L"style", 5, TRUE);
-      static const FX_DWORD s_dwAlignHash =
+      static const uint32_t s_dwAlignHash =
           FX_HashCode_String_GetW(L"align", 5, TRUE);
       if (dwAttriHash == s_dwStyleHash) {
         if (pDecl == NULL) {
           pDecl = FXTARGET_NewWith(m_pInlineStyleStore) CFDE_CSSDeclaration;
         }
         AppendInlineStyle(pDecl, wsValue.GetPtr(), wsValue.GetLength());
       } else if (dwAttriHash == s_dwAlignHash) {
         if (pDecl == NULL) {
           pDecl = FXTARGET_NewWith(m_pInlineStyleStore) CFDE_CSSDeclaration;
         }
@@ skipping 1282 matching lines @@
     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;
   }
 }
-FX_DWORD CFDE_CSSStyleSelector::ToTextDecoration(IFDE_CSSValueList* pValue) {
-  FX_DWORD dwDecoration = 0;
+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 =
         (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;
@@ skipping 27 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;
 }