Remove FX_BOOL from xfa.

xfa/fxfa/app/xfa_ffdoc.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/fxfa/xfa_ffdoc.h"
 
 #include <algorithm>
 
@@ skipping 137 matching lines @@
 }  // namespace
 
 CXFA_FFDoc::CXFA_FFDoc(CXFA_FFApp* pApp, IXFA_DocEnvironment* pDocEnvironment)
     : m_pDocEnvironment(pDocEnvironment),
       m_pDocumentParser(nullptr),
       m_pStream(nullptr),
       m_pApp(pApp),
       m_pNotify(nullptr),
       m_pPDFDoc(nullptr),
       m_dwDocType(XFA_DOCTYPE_Static),
-      m_bOwnStream(TRUE) {}
+      m_bOwnStream(true) {}
 
 CXFA_FFDoc::~CXFA_FFDoc() {
   CloseDoc();
 }
 
 uint32_t CXFA_FFDoc::GetDocType() {
   return m_dwDocType;
 }
 
 int32_t CXFA_FFDoc::StartLoad() {
   m_pNotify.reset(new CXFA_FFNotify(this));
   m_pDocumentParser.reset(new CXFA_DocumentParser(m_pNotify.get()));
   int32_t iStatus = m_pDocumentParser->StartParse(m_pStream, XFA_XDPPACKET_XDP);
   return iStatus;
 }
 
-FX_BOOL XFA_GetPDFContentsFromPDFXML(CFDE_XMLNode* pPDFElement,
-                                     uint8_t*& pByteBuffer,
-                                     int32_t& iBufferSize) {
+bool XFA_GetPDFContentsFromPDFXML(CFDE_XMLNode* pPDFElement,
+                                  uint8_t*& pByteBuffer,
+                                  int32_t& iBufferSize) {
   CFDE_XMLElement* pDocumentElement = nullptr;
   for (CFDE_XMLNode* pXMLNode =
            pPDFElement->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLNode; pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFX_WideString wsTagName;
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTagName(wsTagName);
       if (wsTagName == FX_WSTRC(L"document")) {
         pDocumentElement = pXMLElement;
         break;
       }
     }
   }
   if (!pDocumentElement) {
-    return FALSE;
+    return false;
   }
   CFDE_XMLElement* pChunkElement = nullptr;
   for (CFDE_XMLNode* pXMLNode =
            pDocumentElement->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLNode; pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFX_WideString wsTagName;
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTagName(wsTagName);
       if (wsTagName == FX_WSTRC(L"chunk")) {
         pChunkElement = pXMLElement;
         break;
       }
     }
   }
   if (!pChunkElement) {
-    return FALSE;
+    return false;
   }
   CFX_WideString wsPDFContent;
   pChunkElement->GetTextData(wsPDFContent);
   iBufferSize =
       Base64DecodeW(wsPDFContent.c_str(), wsPDFContent.GetLength(), nullptr);
   pByteBuffer = FX_Alloc(uint8_t, iBufferSize + 1);
   pByteBuffer[iBufferSize] = '0';  // FIXME: I bet this is wrong.
   Base64DecodeW(wsPDFContent.c_str(), wsPDFContent.GetLength(), pByteBuffer);
-  return TRUE;
+  return true;
 }
 void XFA_XPDPacket_MergeRootNode(CXFA_Node* pOriginRoot, CXFA_Node* pNewRoot) {
   CXFA_Node* pChildNode = pNewRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
   while (pChildNode) {
     CXFA_Node* pOriginChild =
         pOriginRoot->GetFirstChildByName(pChildNode->GetNameHash());
     if (pOriginChild) {
       pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
     } else {
       CXFA_Node* pNextSibling =
@@ skipping 53 matching lines @@
       return pair.second.get();
   }
   return nullptr;
 }
 
 CXFA_FFDocView* CXFA_FFDoc::GetDocView() {
   auto it = m_TypeToDocViewMap.begin();
   return it != m_TypeToDocViewMap.end() ? it->second.get() : nullptr;
 }
 
-FX_BOOL CXFA_FFDoc::OpenDoc(IFX_SeekableReadStream* pStream,
-                            FX_BOOL bTakeOverFile) {
+bool CXFA_FFDoc::OpenDoc(IFX_SeekableReadStream* pStream, bool bTakeOverFile) {
   m_bOwnStream = bTakeOverFile;
   m_pStream = pStream;
-  return TRUE;
+  return true;
 }
-FX_BOOL CXFA_FFDoc::OpenDoc(CPDF_Document* pPDFDoc) {
+bool CXFA_FFDoc::OpenDoc(CPDF_Document* pPDFDoc) {
   if (!pPDFDoc)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pRoot = pPDFDoc->GetRoot();
   if (!pRoot)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pAcroForm = pRoot->GetDictFor("AcroForm");
   if (!pAcroForm)
-    return FALSE;
+    return false;
 
   CPDF_Object* pElementXFA = pAcroForm->GetDirectObjectFor("XFA");
   if (!pElementXFA)
-    return FALSE;
+    return false;
 
   std::vector<CPDF_Stream*> xfaStreams;
   if (pElementXFA->IsArray()) {
     CPDF_Array* pXFAArray = (CPDF_Array*)pElementXFA;
     for (size_t i = 0; i < pXFAArray->GetCount() / 2; i++) {
       if (CPDF_Stream* pStream = pXFAArray->GetStreamAt(i * 2 + 1))
         xfaStreams.push_back(pStream);
     }
   } else if (pElementXFA->IsStream()) {
     xfaStreams.push_back((CPDF_Stream*)pElementXFA);
   }
   if (xfaStreams.empty())
-    return FALSE;
+    return false;
 
   IFX_SeekableReadStream* pFileRead = new CXFA_FileRead(xfaStreams);
   m_pPDFDoc = pPDFDoc;
   if (m_pStream) {
     m_pStream->Release();
     m_pStream = nullptr;
   }
   m_pStream = pFileRead;
-  m_bOwnStream = TRUE;
-  return TRUE;
+  m_bOwnStream = true;
+  return true;
 }
 
-FX_BOOL CXFA_FFDoc::CloseDoc() {
+bool CXFA_FFDoc::CloseDoc() {
   for (const auto& pair : m_TypeToDocViewMap)
     pair.second->RunDocClose();
 
   CXFA_Document* doc =
       m_pDocumentParser ? m_pDocumentParser->GetDocument() : nullptr;
   if (doc)
     doc->ClearLayoutData();
 
   m_TypeToDocViewMap.clear();
 
   m_pNotify.reset(nullptr);
   m_pApp->GetXFAFontMgr()->ReleaseDocFonts(this);
 
   if (m_dwDocType != XFA_DOCTYPE_XDP && m_pStream && m_bOwnStream) {
     m_pStream->Release();
     m_pStream = nullptr;
   }
 
   for (const auto& pair : m_HashToDibDpiMap)
     delete pair.second.pDibSource;
 
   m_HashToDibDpiMap.clear();
   m_pApp->ClearEventTargets();
-  return TRUE;
+  return true;
 }
 void CXFA_FFDoc::SetDocType(uint32_t dwType) {
   m_dwDocType = dwType;
 }
 CPDF_Document* CXFA_FFDoc::GetPDFDoc() {
   return m_pPDFDoc;
 }
 
 CFX_DIBitmap* CXFA_FFDoc::GetPDFNamedImage(const CFX_WideStringC& wsName,
                                            int32_t& iImageXDpi,
@@ skipping 64 matching lines @@
     return !!pExport->Export(pFile);
 
   CFX_ByteString bsChecksum;
   if (pCSContext)
     bsChecksum = pCSContext->GetChecksum();
 
   return !!pExport->Export(
       pFile, pNode, 0, bsChecksum.GetLength() ? bsChecksum.c_str() : nullptr);
 }
 
-FX_BOOL CXFA_FFDoc::ImportData(IFX_SeekableReadStream* pStream, FX_BOOL bXDP) {
+bool CXFA_FFDoc::ImportData(IFX_SeekableReadStream* pStream, bool bXDP) {
   std::unique_ptr<CXFA_DataImporter> importer(
       new CXFA_DataImporter(m_pDocumentParser->GetDocument()));
   return importer->ImportData(pStream);
 }