Remove FX_BOOL from fpdfsdk.

fpdfsdk/fpdfview.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 "public/fpdfview.h"
 
 #include <memory>
 #include <utility>
@@ skipping 206 matching lines @@
     default:
       break;
   }
 }
 
 FPDF_BOOL FSDK_IsSandBoxPolicyEnabled(FPDF_DWORD policy) {
   switch (policy) {
     case FPDF_POLICY_MACHINETIME_ACCESS:
       return !!(foxit_sandbox_policy & 0x01);
     default:
-      return FALSE;
+      return false;
   }
 }
 
 CCodec_ModuleMgr* g_pCodecModule = nullptr;
 
 DLLEXPORT void STDCALL FPDF_InitLibrary() {
   FPDF_InitLibraryWithConfig(nullptr);
 }
 
 DLLEXPORT void STDCALL
@@ skipping 104 matching lines @@
     ProcessParseError(error);
     return nullptr;
   }
   return FPDFDocumentFromCPDFDocument(pDocument.release());
 }
 
 #ifdef PDF_ENABLE_XFA
 DLLEXPORT FPDF_BOOL STDCALL FPDF_HasXFAField(FPDF_DOCUMENT document,
                                              int* docType) {
   if (!document)
-    return FALSE;
+    return false;
 
   CPDF_Document* pdfDoc =
       (static_cast<CPDFXFA_Context*>(document))->GetPDFDoc();
   if (!pdfDoc)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pRoot = pdfDoc->GetRoot();
   if (!pRoot)
-    return FALSE;
+    return false;
 
   CPDF_Dictionary* pAcroForm = pRoot->GetDictFor("AcroForm");
   if (!pAcroForm)
-    return FALSE;
+    return false;
 
   CPDF_Object* pXFA = pAcroForm->GetObjectFor("XFA");
   if (!pXFA)
-    return FALSE;
+    return false;
 
   bool bDynamicXFA = pRoot->GetBooleanFor("NeedsRendering", false);
   *docType = bDynamicXFA ? DOCTYPE_DYNAMIC_XFA : DOCTYPE_STATIC_XFA;
-  return TRUE;
+  return true;
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_LoadXFA(FPDF_DOCUMENT document) {
   return document && (static_cast<CPDFXFA_Context*>(document))->LoadXFADoc();
 }
 #endif  // PDF_ENABLE_XFA
 
 class CMemFile final : public IFX_SeekableReadStream {
  public:
   CMemFile(uint8_t* pBuf, FX_FILESIZE size) : m_pBuf(pBuf), m_size(size) {}
@@ skipping 55 matching lines @@
     ProcessParseError(error);
     return nullptr;
   }
   CheckUnSupportError(pDocument.get(), error);
   return FPDFDocumentFromCPDFDocument(pDocument.release());
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
                                                 int* fileVersion) {
   if (!fileVersion)
-    return FALSE;
+    return false;
 
   *fileVersion = 0;
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(doc);
   if (!pDoc)
-    return FALSE;
+    return false;
 
   CPDF_Parser* pParser = pDoc->GetParser();
   if (!pParser)
-    return FALSE;
+    return false;
 
   *fileVersion = pParser->GetFileVersion();
-  return TRUE;
+  return true;
 }
 
 // jabdelmalek: changed return type from uint32_t to build on Linux (and match
 // header).
 DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   // https://bugs.chromium.org/p/pdfium/issues/detail?id=499
   if (!pDoc) {
 #ifndef PDF_ENABLE_XFA
     return 0;
@@ skipping 75 matching lines @@
     pBitmap->Create(size_x, size_y, FXDIB_Argb);
     pBitmap->Clear(0x00ffffff);
     CFX_FxgeDevice* pDevice = new CFX_FxgeDevice;
     pContext->m_pDevice = pdfium::WrapUnique(pDevice);
     pDevice->Attach(pBitmap.get(), false, nullptr, false);
   } else {
     pContext->m_pDevice = pdfium::MakeUnique<CFX_WindowsDevice>(dc);
   }
 
   FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y,
-                         rotate, flags, TRUE, nullptr);
+                         rotate, flags, true, nullptr);
 
   if (bNewBitmap) {
     CFX_WindowsDevice WinDC(dc);
     if (WinDC.GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
       std::unique_ptr<CFX_DIBitmap> pDst = pdfium::MakeUnique<CFX_DIBitmap>();
       int pitch = pBitmap->GetPitch();
       pDst->Create(size_x, size_y, FXDIB_Rgb32);
       FXSYS_memset(pDst->GetBuffer(), -1, pitch * size_y);
       pDst->CompositeBitmap(0, 0, size_x, size_y, pBitmap.get(), 0, 0,
-                            FXDIB_BLEND_NORMAL, nullptr, FALSE, nullptr);
+                            FXDIB_BLEND_NORMAL, nullptr, false, nullptr);
       WinDC.StretchDIBits(pDst.get(), 0, 0, size_x, size_y);
     } else {
       WinDC.SetDIBits(pBitmap.get(), 0, 0);
     }
   }
 
   pPage->SetRenderContext(nullptr);
 }
 #endif  // defined(_WIN32)
 
@@ skipping 13 matching lines @@
     return;
 
   CPDF_PageRenderContext* pContext = new CPDF_PageRenderContext;
   pPage->SetRenderContext(pdfium::WrapUnique(pContext));
   CFX_FxgeDevice* pDevice = new CFX_FxgeDevice;
   pContext->m_pDevice.reset(pDevice);
   CFX_DIBitmap* pBitmap = CFXBitmapFromFPDFBitmap(bitmap);
   pDevice->Attach(pBitmap, !!(flags & FPDF_REVERSE_BYTE_ORDER), nullptr, false);
 
   FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y,
-                         rotate, flags, TRUE, nullptr);
+                         rotate, flags, true, nullptr);
 
   pPage->SetRenderContext(nullptr);
 }
 
 #ifdef _SKIA_SUPPORT_
 DLLEXPORT FPDF_RECORDER STDCALL FPDF_RenderPageSkp(FPDF_PAGE page,
                                                    int size_x,
                                                    int size_y) {
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
   if (!pPage)
     return nullptr;
 
   CPDF_PageRenderContext* pContext = new CPDF_PageRenderContext;
   pPage->SetRenderContext(pdfium::WrapUnique(pContext));
   CFX_FxgeDevice* skDevice = new CFX_FxgeDevice;
   FPDF_RECORDER recorder = skDevice->CreateRecorder(size_x, size_y);
   pContext->m_pDevice.reset(skDevice);
-  FPDF_RenderPage_Retail(pContext, page, 0, 0, size_x, size_y, 0, 0, TRUE,
+  FPDF_RenderPage_Retail(pContext, page, 0, 0, size_x, size_y, 0, 0, true,
                          nullptr);
   pPage->SetRenderContext(nullptr);
   return recorder;
 }
 #endif
 
 DLLEXPORT void STDCALL FPDF_ClosePage(FPDF_PAGE page) {
   UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
   if (!page)
     return;
@@ skipping 169 matching lines @@
 }
 
 void FPDF_RenderPage_Retail(CPDF_PageRenderContext* pContext,
                             FPDF_PAGE page,
                             int start_x,
                             int start_y,
                             int size_x,
                             int size_y,
                             int rotate,
                             int flags,
-                            FX_BOOL bNeedToRestore,
+                            bool bNeedToRestore,
                             IFSDK_PAUSE_Adapter* pause) {
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
   if (!pPage)
     return;
 
   if (!pContext->m_pOptions)
     pContext->m_pOptions = pdfium::MakeUnique<CPDF_RenderOptions>();
 
   if (flags & FPDF_LCD_TEXT)
     pContext->m_pOptions->m_Flags |= RENDER_CLEARTYPE;
@@ skipping 30 matching lines @@
 
   pContext->m_pDevice->SaveState();
   pContext->m_pDevice->SetClip_Rect(
       FX_RECT(start_x, start_y, start_x + size_x, start_y + size_y));
 
   pContext->m_pContext = pdfium::MakeUnique<CPDF_RenderContext>(pPage);
   pContext->m_pContext->AppendLayer(pPage, &matrix);
 
   if (flags & FPDF_ANNOT) {
     pContext->m_pAnnots = pdfium::MakeUnique<CPDF_AnnotList>(pPage);
-    FX_BOOL bPrinting = pContext->m_pDevice->GetDeviceClass() != FXDC_DISPLAY;
+    bool bPrinting = pContext->m_pDevice->GetDeviceClass() != FXDC_DISPLAY;
     pContext->m_pAnnots->DisplayAnnots(pPage, pContext->m_pContext.get(),
-                                       bPrinting, &matrix, FALSE, nullptr);
+                                       bPrinting, &matrix, false, nullptr);
   }
 
   pContext->m_pRenderer = pdfium::MakeUnique<CPDF_ProgressiveRenderer>(
       pContext->m_pContext.get(), pContext->m_pDevice.get(),
       pContext->m_pOptions.get());
   pContext->m_pRenderer->Start(pause);
   if (bNeedToRestore)
     pContext->m_pDevice->RestoreState(false);
 }
 
 DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document,
                                               int page_index,
                                               double* width,
                                               double* height) {
   UnderlyingDocumentType* pDoc = UnderlyingFromFPDFDocument(document);
   if (!pDoc)
-    return FALSE;
+    return false;
 
 #ifdef PDF_ENABLE_XFA
   int count = pDoc->GetPageCount();
   if (page_index < 0 || page_index >= count)
-    return FALSE;
+    return false;
   CPDFXFA_Page* pPage = pDoc->GetXFAPage(page_index);
   if (!pPage)
-    return FALSE;
+    return false;
   *width = pPage->GetPageWidth();
   *height = pPage->GetPageHeight();
 #else   // PDF_ENABLE_XFA
   CPDF_Dictionary* pDict = pDoc->GetPage(page_index);
   if (!pDict)
-    return FALSE;
+    return false;
 
   CPDF_Page page(pDoc, pDict, true);
   *width = page.GetPageWidth();
   *height = page.GetPageHeight();
 #endif  // PDF_ENABLE_XFA
 
-  return TRUE;
+  return true;
 }
 
 DLLEXPORT FPDF_BOOL STDCALL
 FPDF_VIEWERREF_GetPrintScaling(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pDoc)
-    return TRUE;
+    return true;
   CPDF_ViewerPreferences viewRef(pDoc);
   return viewRef.PrintScaling();
 }
 
 DLLEXPORT int STDCALL FPDF_VIEWERREF_GetNumCopies(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pDoc)
     return 1;
   CPDF_ViewerPreferences viewRef(pDoc);
   return viewRef.NumCopies();
@@ skipping 173 matching lines @@
   if (!buffer) {
     *buflen = len;
   } else if (*buflen >= len) {
     memcpy(buffer, utf16Name.c_str(), len);
     *buflen = len;
   } else {
     *buflen = -1;
   }
   return (FPDF_DEST)pDestObj;
 }