Make code compile with clang_use_chrome_plugin (final)

xfa/fde/css/fde_cssstylesheet.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_cssstylesheet.h"
 
 #include <memory>
 
@@ skipping 41 matching lines @@
     IFX_Stream* pStream,
     uint16_t wCodePage,
     uint32_t dwMediaList) {
   CFDE_CSSStyleSheet* pStyleSheet = new CFDE_CSSStyleSheet(dwMediaList);
   if (!pStyleSheet->LoadFromStream(szUrl, pStream, wCodePage)) {
     pStyleSheet->Release();
     pStyleSheet = nullptr;
   }
   return pStyleSheet;
 }
+
 IFDE_CSSStyleSheet* IFDE_CSSStyleSheet::LoadFromBuffer(
     const CFX_WideString& szUrl,
     const FX_WCHAR* pBuffer,
     int32_t iBufSize,
     uint16_t wCodePage,
     uint32_t dwMediaList) {
   CFDE_CSSStyleSheet* pStyleSheet = new CFDE_CSSStyleSheet(dwMediaList);
   if (!pStyleSheet->LoadFromBuffer(szUrl, pBuffer, iBufSize, wCodePage)) {
     pStyleSheet->Release();
     pStyleSheet = nullptr;
   }
   return pStyleSheet;
 }
+
 CFDE_CSSStyleSheet::CFDE_CSSStyleSheet(uint32_t dwMediaList)
     : m_wCodePage(FX_CODEPAGE_UTF8),
       m_wRefCount(1),
       m_dwMediaList(dwMediaList),
       m_pAllocator(nullptr) {
   ASSERT(m_dwMediaList > 0);
 }
+
 CFDE_CSSStyleSheet::~CFDE_CSSStyleSheet() {
   Reset();
 }
+
 void CFDE_CSSStyleSheet::Reset() {
   for (int32_t i = m_RuleArray.GetSize() - 1; i >= 0; --i) {
     IFDE_CSSRule* pRule = m_RuleArray.GetAt(i);
     switch (pRule->GetType()) {
       case FDE_CSSRULETYPE_Style:
         static_cast<CFDE_CSSStyleRule*>(pRule)->~CFDE_CSSStyleRule();
         break;
       case FDE_CSSRULETYPE_Media:
         static_cast<CFDE_CSSMediaRule*>(pRule)->~CFDE_CSSMediaRule();
         break;
       case FDE_CSSRULETYPE_FontFace:
         static_cast<CFDE_CSSFontFaceRule*>(pRule)->~CFDE_CSSFontFaceRule();
         break;
       default:
         ASSERT(FALSE);
         break;
     }
   }
   m_RuleArray.RemoveAll();
   m_Selectors.RemoveAll();
   m_StringCache.clear();
   delete m_pAllocator;
   m_pAllocator = nullptr;
 }
+
 uint32_t CFDE_CSSStyleSheet::Retain() {
   return ++m_wRefCount;
 }
+
 uint32_t CFDE_CSSStyleSheet::Release() {
   uint32_t dwRefCount = --m_wRefCount;
   if (dwRefCount == 0) {
     delete this;
   }
   return dwRefCount;
 }
+
+FX_BOOL CFDE_CSSStyleSheet::GetUrl(CFX_WideString& szUrl) {
+  szUrl = m_szUrl;
+  return szUrl.GetLength() > 0;
+}
+
+uint32_t CFDE_CSSStyleSheet::GetMediaList() const {
+  return m_dwMediaList;
+}
+
+uint16_t CFDE_CSSStyleSheet::GetCodePage() const {
+  return m_wCodePage;
+}
+
 int32_t CFDE_CSSStyleSheet::CountRules() const {
   return m_RuleArray.GetSize();
 }
+
 IFDE_CSSRule* CFDE_CSSStyleSheet::GetRule(int32_t index) {
   return m_RuleArray.GetAt(index);
 }
 
 FX_BOOL CFDE_CSSStyleSheet::LoadFromStream(const CFX_WideString& szUrl,
                                            IFX_Stream* pStream,
                                            uint16_t wCodePage) {
   std::unique_ptr<CFDE_CSSSyntaxParser> pSyntax(new CFDE_CSSSyntaxParser);
   if (pStream->GetCodePage() != wCodePage)
     pStream->SetCodePage(wCodePage);
@@ skipping 39 matching lines @@
         eStatus = LoadPageRule(pSyntax);
         break;
       default:
         break;
     }
   } while (eStatus >= FDE_CSSSYNTAXSTATUS_None);
   m_Selectors.RemoveAll();
   m_StringCache.clear();
   return eStatus != FDE_CSSSYNTAXSTATUS_Error;
 }
+
 FDE_CSSSYNTAXSTATUS CFDE_CSSStyleSheet::LoadMediaRule(
     CFDE_CSSSyntaxParser* pSyntax) {
   uint32_t dwMediaList = 0;
   CFDE_CSSMediaRule* pMediaRule = nullptr;
   for (;;) {
     switch (pSyntax->DoSyntaxParse()) {
       case FDE_CSSSYNTAXSTATUS_MediaType: {
         int32_t iLen;
         const FX_WCHAR* psz = pSyntax->GetCurrentString(iLen);
         FDE_LPCCSSMEDIATYPETABLE pMediaType =
@@ skipping 18 matching lines @@
               FXTARGET_NewWith(m_pAllocator) CFDE_CSSMediaRule(dwMediaList);
           m_RuleArray.Add(pMediaRule);
         }
         break;
       case FDE_CSSSYNTAXSTATUS_DeclClose:
         return FDE_CSSSYNTAXSTATUS_None;
         FDE_CSSSWITCHDEFAULTS();
     }
   }
 }
+
 FDE_CSSSYNTAXSTATUS CFDE_CSSStyleSheet::LoadStyleRule(
     CFDE_CSSSyntaxParser* pSyntax,
     CFDE_CSSRuleArray& ruleArray) {
   m_Selectors.RemoveAt(0, m_Selectors.GetSize());
   CFDE_CSSStyleRule* pStyleRule = nullptr;
   const FX_WCHAR* pszValue = nullptr;
   int32_t iValueLen = 0;
   FDE_CSSPROPERTYARGS propertyArgs;
   propertyArgs.pStaticStore = m_pAllocator;
   propertyArgs.pStringCache = &m_StringCache;
@@ skipping 44 matching lines @@
       case FDE_CSSSYNTAXSTATUS_DeclClose:
         if (pStyleRule && !pStyleRule->GetDeclImp().GetStartPosition()) {
           pStyleRule->~CFDE_CSSStyleRule();
           ruleArray.RemoveLast(1);
         }
         return FDE_CSSSYNTAXSTATUS_None;
         FDE_CSSSWITCHDEFAULTS();
     }
   }
 }
+
 FDE_CSSSYNTAXSTATUS CFDE_CSSStyleSheet::LoadFontFaceRule(
     CFDE_CSSSyntaxParser* pSyntax,
     CFDE_CSSRuleArray& ruleArray) {
   CFDE_CSSFontFaceRule* pFontFaceRule = nullptr;
   const FX_WCHAR* pszValue = nullptr;
   int32_t iValueLen = 0;
   FDE_CSSPROPERTYARGS propertyArgs;
   propertyArgs.pStaticStore = m_pAllocator;
   propertyArgs.pStringCache = &m_StringCache;
   propertyArgs.pProperty = nullptr;
@@ skipping 18 matching lines @@
           pFontFaceRule = FXTARGET_NewWith(m_pAllocator) CFDE_CSSFontFaceRule;
           ruleArray.Add(pFontFaceRule);
         }
         break;
       case FDE_CSSSYNTAXSTATUS_DeclClose:
         return FDE_CSSSYNTAXSTATUS_None;
         FDE_CSSSWITCHDEFAULTS();
     }
   }
 }
+
 FDE_CSSSYNTAXSTATUS CFDE_CSSStyleSheet::LoadImportRule(
     CFDE_CSSSyntaxParser* pSyntax) {
   for (;;) {
     switch (pSyntax->DoSyntaxParse()) {
       case FDE_CSSSYNTAXSTATUS_ImportClose:
         return FDE_CSSSYNTAXSTATUS_None;
       case FDE_CSSSYNTAXSTATUS_URI:
         break;
         FDE_CSSSWITCHDEFAULTS();
     }
   }
 }
+
 FDE_CSSSYNTAXSTATUS CFDE_CSSStyleSheet::LoadPageRule(
     CFDE_CSSSyntaxParser* pSyntax) {
   return SkipRuleSet(pSyntax);
 }
+
 FDE_CSSSYNTAXSTATUS CFDE_CSSStyleSheet::SkipRuleSet(
     CFDE_CSSSyntaxParser* pSyntax) {
   for (;;) {
     switch (pSyntax->DoSyntaxParse()) {
       case FDE_CSSSYNTAXSTATUS_Selector:
       case FDE_CSSSYNTAXSTATUS_DeclOpen:
       case FDE_CSSSYNTAXSTATUS_PropertyName:
       case FDE_CSSSYNTAXSTATUS_PropertyValue:
         break;
       case FDE_CSSSYNTAXSTATUS_DeclClose:
         return FDE_CSSSYNTAXSTATUS_None;
         FDE_CSSSWITCHDEFAULTS();
     }
   }
 }
+
+CFDE_CSSStyleRule::CFDE_CSSStyleRule() : m_ppSelector(NULL), m_iSelectors(0) {}
+
+int32_t CFDE_CSSStyleRule::CountSelectorLists() const {
+  return m_iSelectors;
+}
+
+CFDE_CSSSelector* CFDE_CSSStyleRule::GetSelectorList(int32_t index) const {
+  return m_ppSelector[index];
+}
+
+CFDE_CSSDeclaration* CFDE_CSSStyleRule::GetDeclaration() {
+  return &m_Declaration;
+}
+
 void CFDE_CSSStyleRule::SetSelector(IFX_MemoryAllocator* pStaticStore,
                                     const CFDE_CSSSelectorArray& list) {
   ASSERT(!m_ppSelector);
   m_iSelectors = list.GetSize();
   m_ppSelector = static_cast<CFDE_CSSSelector**>(
       pStaticStore->Alloc(m_iSelectors * sizeof(CFDE_CSSSelector*)));
   for (int32_t i = 0; i < m_iSelectors; ++i) {
     m_ppSelector[i] = list.GetAt(i);
   }
 }
+
+CFDE_CSSMediaRule::CFDE_CSSMediaRule(uint32_t dwMediaList)
+    : m_dwMediaList(dwMediaList) {}
+
 CFDE_CSSMediaRule::~CFDE_CSSMediaRule() {
   for (int32_t i = m_RuleArray.GetSize() - 1; i >= 0; --i) {
     IFDE_CSSRule* pRule = m_RuleArray.GetAt(i);
     switch (pRule->GetType()) {
       case FDE_CSSRULETYPE_Style:
         ((CFDE_CSSStyleRule*)pRule)->~CFDE_CSSStyleRule();
         break;
       default:
         ASSERT(FALSE);
         break;
     }
   }
 }
-inline FX_BOOL FDE_IsCSSChar(FX_WCHAR wch) {
+
+uint32_t CFDE_CSSMediaRule::GetMediaList() const {
+  return m_dwMediaList;
+}
+
+int32_t CFDE_CSSMediaRule::CountRules() const {
+  return m_RuleArray.GetSize();
+}
+
+IFDE_CSSRule* CFDE_CSSMediaRule::GetRule(int32_t index) {
+  return m_RuleArray.GetAt(index);
+}
+
+FX_BOOL FDE_IsCSSChar(FX_WCHAR wch) {
   return (wch >= 'a' && wch <= 'z') || (wch >= 'A' && wch <= 'Z');
 }
+
 int32_t FDE_GetCSSPersudoLen(const FX_WCHAR* psz, const FX_WCHAR* pEnd) {
   ASSERT(*psz == ':');
   const FX_WCHAR* pStart = psz;
   while (psz < pEnd) {
     FX_WCHAR wch = *psz;
     if (FDE_IsCSSChar(wch) || wch == ':') {
       ++psz;
     } else {
       break;
     }
   }
   return psz - pStart;
 }
+
 int32_t FDE_GetCSSNameLen(const FX_WCHAR* psz, const FX_WCHAR* pEnd) {
   const FX_WCHAR* pStart = psz;
   while (psz < pEnd) {
     FX_WCHAR wch = *psz;
     if (FDE_IsCSSChar(wch) || (wch >= '0' && wch <= '9') || wch == '_' ||
         wch == '-') {
       ++psz;
     } else {
       break;
     }
   }
   return psz - pStart;
 }
+
+CFDE_CSSSelector::CFDE_CSSSelector(FDE_CSSSELECTORTYPE eType,
+                                   const FX_WCHAR* psz,
+                                   int32_t iLen,
+                                   bool bIgnoreCase)
+    : m_eType(eType),
+      m_dwHash(FX_HashCode_GetW(CFX_WideStringC(psz, iLen), bIgnoreCase)),
+      m_pNext(nullptr) {}
+
+FDE_CSSSELECTORTYPE CFDE_CSSSelector::GetType() const {
+  return m_eType;
+}
+
+uint32_t CFDE_CSSSelector::GetNameHash() const {
+  return m_dwHash;
+}
+
+CFDE_CSSSelector* CFDE_CSSSelector::GetNextSelector() const {
+  return m_pNext;
+}
+
 CFDE_CSSSelector* CFDE_CSSSelector::FromString(
     IFX_MemoryAllocator* pStaticStore,
     const FX_WCHAR* psz,
     int32_t iLen) {
   ASSERT(pStaticStore && psz && iLen > 0);
+
   const FX_WCHAR* pStart = psz;
   const FX_WCHAR* pEnd = psz + iLen;
   for (; psz < pEnd; ++psz) {
     switch (*psz) {
       case '>':
       case '[':
       case '+':
         return nullptr;
     }
   }
@@ skipping 70 matching lines @@
     } else {
       return nullptr;
     }
   }
   if (!pPersudoFirst)
     return pFirst;
 
   pPersudoLast->SetNext(pFirst);
   return pPersudoFirst;
 }
+
+CFDE_CSSDeclaration* CFDE_CSSFontFaceRule::GetDeclaration() {
+  return &m_Declaration;
+}