Remove FX_BOOL from core

core/fxge/win32/fx_win32_device.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 <crtdbg.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 301 matching lines @@
           }
           ++np;
         }
       }
     }
   }
   return np;
 }
 #endif  // _SKIA_SUPPORT_
 
-FX_BOOL MatrixNoScaled(const CFX_Matrix* pMatrix) {
+bool MatrixNoScaled(const CFX_Matrix* pMatrix) {
   return pMatrix->GetA() == 1.0f && pMatrix->GetB() == 0 &&
          pMatrix->GetC() == 0 && pMatrix->GetD() == 1.0f;
 }
 
 class CFX_Win32FallbackFontInfo final : public CFX_FolderFontInfo {
  public:
   CFX_Win32FallbackFontInfo() {}
   ~CFX_Win32FallbackFontInfo() override {}
 
   // CFX_FolderFontInfo:
   void* MapFont(int weight,
-                FX_BOOL bItalic,
+                bool bItalic,
                 int charset,
                 int pitch_family,
                 const FX_CHAR* family,
                 int& iExact) override;
 };
 
 class CFX_Win32FontInfo final : public IFX_SystemFontInfo {
  public:
   CFX_Win32FontInfo();
   ~CFX_Win32FontInfo() override;
 
   // IFX_SystemFontInfo
-  FX_BOOL EnumFontList(CFX_FontMapper* pMapper) override;
+  bool EnumFontList(CFX_FontMapper* pMapper) override;
   void* MapFont(int weight,
-                FX_BOOL bItalic,
+                bool bItalic,
                 int charset,
                 int pitch_family,
                 const FX_CHAR* face,
                 int& iExact) override;
   void* GetFont(const FX_CHAR* face) override { return nullptr; }
   uint32_t GetFontData(void* hFont,
                        uint32_t table,
                        uint8_t* buffer,
                        uint32_t size) override;
-  FX_BOOL GetFaceName(void* hFont, CFX_ByteString& name) override;
-  FX_BOOL GetFontCharset(void* hFont, int& charset) override;
+  bool GetFaceName(void* hFont, CFX_ByteString& name) override;
+  bool GetFontCharset(void* hFont, int& charset) override;
   void DeleteFont(void* hFont) override;
 
-  FX_BOOL IsOpenTypeFromDiv(const LOGFONTA* plf);
-  FX_BOOL IsSupportFontFormDiv(const LOGFONTA* plf);
+  bool IsOpenTypeFromDiv(const LOGFONTA* plf);
+  bool IsSupportFontFormDiv(const LOGFONTA* plf);
   void AddInstalledFont(const LOGFONTA* plf, uint32_t FontType);
   void GetGBPreference(CFX_ByteString& face, int weight, int picth_family);
   void GetJapanesePreference(CFX_ByteString& face,
                              int weight,
                              int picth_family);
   CFX_ByteString FindFont(const CFX_ByteString& name);
 
   HDC m_hDC;
   CFX_FontMapper* m_pMapper;
   CFX_ByteString m_LastFamily;
   CFX_ByteString m_KaiTi, m_FangSong;
 };
 
 int CALLBACK FontEnumProc(const LOGFONTA* plf,
                           const TEXTMETRICA* lpntme,
                           uint32_t FontType,
                           LPARAM lParam) {
   CFX_Win32FontInfo* pFontInfo = reinterpret_cast<CFX_Win32FontInfo*>(lParam);
   pFontInfo->AddInstalledFont(plf, FontType);
   return 1;
 }
 
 CFX_Win32FontInfo::CFX_Win32FontInfo() : m_hDC(CreateCompatibleDC(nullptr)) {}
 
 CFX_Win32FontInfo::~CFX_Win32FontInfo() {
   DeleteDC(m_hDC);
 }
 
-FX_BOOL CFX_Win32FontInfo::IsOpenTypeFromDiv(const LOGFONTA* plf) {
+bool CFX_Win32FontInfo::IsOpenTypeFromDiv(const LOGFONTA* plf) {
   HFONT hFont = CreateFontIndirectA(plf);
-  FX_BOOL ret = FALSE;
+  bool ret = false;
   uint32_t font_size = GetFontData(hFont, 0, nullptr, 0);
   if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) {
     uint32_t lVersion = 0;
     GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t));
     lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) |
                ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 |
                ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 |
                ((uint8_t)(lVersion >> 24));
     if (lVersion == FXBSTR_ID('O', 'T', 'T', 'O') || lVersion == 0x00010000 ||
         lVersion == FXBSTR_ID('t', 't', 'c', 'f') ||
         lVersion == FXBSTR_ID('t', 'r', 'u', 'e') || lVersion == 0x00020000) {
-      ret = TRUE;
+      ret = true;
     }
   }
   DeleteFont(hFont);
   return ret;
 }
 
-FX_BOOL CFX_Win32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf) {
+bool CFX_Win32FontInfo::IsSupportFontFormDiv(const LOGFONTA* plf) {
   HFONT hFont = CreateFontIndirectA(plf);
-  FX_BOOL ret = FALSE;
+  bool ret = false;
   uint32_t font_size = GetFontData(hFont, 0, nullptr, 0);
   if (font_size != GDI_ERROR && font_size >= sizeof(uint32_t)) {
     uint32_t lVersion = 0;
     GetFontData(hFont, 0, (uint8_t*)(&lVersion), sizeof(uint32_t));
     lVersion = (((uint32_t)(uint8_t)(lVersion)) << 24) |
                ((uint32_t)((uint8_t)(lVersion >> 8))) << 16 |
                ((uint32_t)((uint8_t)(lVersion >> 16))) << 8 |
                ((uint8_t)(lVersion >> 24));
     if (lVersion == FXBSTR_ID('O', 'T', 'T', 'O') || lVersion == 0x00010000 ||
         lVersion == FXBSTR_ID('t', 't', 'c', 'f') ||
         lVersion == FXBSTR_ID('t', 'r', 'u', 'e') || lVersion == 0x00020000 ||
         (lVersion & 0xFFFF0000) == FXBSTR_ID(0x80, 0x01, 0x00, 0x00) ||
         (lVersion & 0xFFFF0000) == FXBSTR_ID('%', '!', 0, 0)) {
-      ret = TRUE;
+      ret = true;
     }
   }
   DeleteFont(hFont);
   return ret;
 }
 
 void CFX_Win32FontInfo::AddInstalledFont(const LOGFONTA* plf,
                                          uint32_t FontType) {
   CFX_ByteString name(plf->lfFaceName);
   if (name[0] == '@')
     return;
 
   if (name == m_LastFamily) {
     m_pMapper->AddInstalledFont(name, plf->lfCharSet);
     return;
   }
   if (!(FontType & TRUETYPE_FONTTYPE)) {
     if (!(FontType & DEVICE_FONTTYPE) || !IsSupportFontFormDiv(plf))
       return;
   }
 
   m_pMapper->AddInstalledFont(name, plf->lfCharSet);
   m_LastFamily = name;
 }
 
-FX_BOOL CFX_Win32FontInfo::EnumFontList(CFX_FontMapper* pMapper) {
+bool CFX_Win32FontInfo::EnumFontList(CFX_FontMapper* pMapper) {
   m_pMapper = pMapper;
   LOGFONTA lf;
   FXSYS_memset(&lf, 0, sizeof(LOGFONTA));
   lf.lfCharSet = FXFONT_DEFAULT_CHARSET;
   lf.lfFaceName[0] = 0;
   lf.lfPitchAndFamily = 0;
   EnumFontFamiliesExA(m_hDC, &lf, (FONTENUMPROCA)FontEnumProc, (uintptr_t) this,
                       0);
-  return TRUE;
+  return true;
 }
 
 CFX_ByteString CFX_Win32FontInfo::FindFont(const CFX_ByteString& name) {
   if (!m_pMapper)
     return name;
 
   for (size_t i = 0; i < m_pMapper->m_InstalledTTFonts.size(); ++i) {
     CFX_ByteString thisname = m_pMapper->m_InstalledTTFonts[i];
     if (thisname.Left(name.GetLength()) == name)
       return m_pMapper->m_InstalledTTFonts[i];
   }
   for (size_t i = 0; i < m_pMapper->m_LocalizedTTFonts.size(); ++i) {
     CFX_ByteString thisname = m_pMapper->m_LocalizedTTFonts[i].first;
     if (thisname.Left(name.GetLength()) == name)
       return m_pMapper->m_LocalizedTTFonts[i].second;
   }
   return CFX_ByteString();
 }
 
 void* CFX_Win32FallbackFontInfo::MapFont(int weight,
-                                         FX_BOOL bItalic,
+                                         bool bItalic,
                                          int charset,
                                          int pitch_family,
                                          const FX_CHAR* cstr_face,
                                          int& iExact) {
   void* font = GetSubstFont(cstr_face);
   if (font) {
     iExact = 1;
     return font;
   }
-  FX_BOOL bCJK = TRUE;
+  bool bCJK = true;
   switch (charset) {
     case FXFONT_SHIFTJIS_CHARSET:
     case FXFONT_GB2312_CHARSET:
     case FXFONT_CHINESEBIG5_CHARSET:
     case FXFONT_HANGUL_CHARSET:
     default:
-      bCJK = FALSE;
+      bCJK = false;
       break;
   }
   return FindFont(weight, bItalic, charset, pitch_family, cstr_face, !bCJK);
 }
 
 void CFX_Win32FontInfo::GetGBPreference(CFX_ByteString& face,
                                         int weight,
                                         int picth_family) {
   if (face.Find("KaiTi") >= 0 || face.Find("\xbf\xac") >= 0) {
     if (m_KaiTi.IsEmpty()) {
@@ skipping 54 matching lines @@
     return;
 
   if (!(picth_family & FF_ROMAN) && weight > 400) {
     face = "MS PGothic";
   } else {
     face = "MS PMincho";
   }
 }
 
 void* CFX_Win32FontInfo::MapFont(int weight,
-                                 FX_BOOL bItalic,
+                                 bool bItalic,
                                  int charset,
                                  int pitch_family,
                                  const FX_CHAR* cstr_face,
                                  int& iExact) {
   CFX_ByteString face = cstr_face;
   int iBaseFont;
   for (iBaseFont = 0; iBaseFont < 12; iBaseFont++)
     if (face == CFX_ByteStringC(g_Base14Substs[iBaseFont].m_pName)) {
       face = g_Base14Substs[iBaseFont].m_pWinName;
       weight = g_Base14Substs[iBaseFont].m_bBold ? FW_BOLD : FW_NORMAL;
       bItalic = g_Base14Substs[iBaseFont].m_bItalic;
-      iExact = TRUE;
+      iExact = true;
       break;
     }
   if (charset == FXFONT_ANSI_CHARSET || charset == FXFONT_SYMBOL_CHARSET) {
     charset = FXFONT_DEFAULT_CHARSET;
   }
   int subst_pitch_family = pitch_family;
   switch (charset) {
     case FXFONT_SHIFTJIS_CHARSET:
       subst_pitch_family = FF_ROMAN;
       break;
@@ skipping 64 matching lines @@
   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
   table = FXDWORD_GET_MSBFIRST(reinterpret_cast<uint8_t*>(&table));
   size = ::GetFontData(m_hDC, table, 0, buffer, size);
   ::SelectObject(m_hDC, hOldFont);
   if (size == GDI_ERROR) {
     return 0;
   }
   return size;
 }
 
-FX_BOOL CFX_Win32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name) {
+bool CFX_Win32FontInfo::GetFaceName(void* hFont, CFX_ByteString& name) {
   char facebuf[100];
   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
   int ret = ::GetTextFaceA(m_hDC, 100, facebuf);
   ::SelectObject(m_hDC, hOldFont);
   if (ret == 0) {
-    return FALSE;
+    return false;
   }
   name = facebuf;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CFX_Win32FontInfo::GetFontCharset(void* hFont, int& charset) {
+bool CFX_Win32FontInfo::GetFontCharset(void* hFont, int& charset) {
   TEXTMETRIC tm;
   HFONT hOldFont = (HFONT)::SelectObject(m_hDC, (HFONT)hFont);
   ::GetTextMetrics(m_hDC, &tm);
   ::SelectObject(m_hDC, hOldFont);
   charset = tm.tmCharSet;
-  return TRUE;
+  return true;
 }
 
 }  // namespace
 
 std::unique_ptr<IFX_SystemFontInfo> IFX_SystemFontInfo::CreateDefault(
     const char** pUnused) {
   if (IsGDIEnabled())
     return std::unique_ptr<IFX_SystemFontInfo>(new CFX_Win32FontInfo);
 
   // Select the fallback font information class if GDI is disabled.
@@ skipping 76 matching lines @@
 void CGdiDeviceDriver::SaveState() {
   SaveDC(m_hDC);
 }
 
 void CGdiDeviceDriver::RestoreState(bool bKeepSaved) {
   RestoreDC(m_hDC, -1);
   if (bKeepSaved)
     SaveDC(m_hDC);
 }
 
-FX_BOOL CGdiDeviceDriver::GDI_SetDIBits(CFX_DIBitmap* pBitmap1,
-                                        const FX_RECT* pSrcRect,
-                                        int left,
-                                        int top) {
+bool CGdiDeviceDriver::GDI_SetDIBits(CFX_DIBitmap* pBitmap1,
+                                     const FX_RECT* pSrcRect,
+                                     int left,
+                                     int top) {
   if (m_DeviceClass == FXDC_PRINTER) {
-    std::unique_ptr<CFX_DIBitmap> pBitmap(pBitmap1->FlipImage(FALSE, TRUE));
+    std::unique_ptr<CFX_DIBitmap> pBitmap(pBitmap1->FlipImage(false, true));
     if (!pBitmap)
-      return FALSE;
+      return false;
 
     if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb))
-      return FALSE;
+      return false;
 
     int width = pSrcRect->Width(), height = pSrcRect->Height();
     LPBYTE pBuffer = pBitmap->GetBuffer();
     CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap.get());
     ((BITMAPINFOHEADER*)info.c_str())->biHeight *= -1;
     FX_RECT dst_rect(0, 0, width, height);
     dst_rect.Intersect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
     int dst_width = dst_rect.Width();
     int dst_height = dst_rect.Height();
     ::StretchDIBits(m_hDC, left, top, dst_width, dst_height, 0, 0, dst_width,
                     dst_height, pBuffer, (BITMAPINFO*)info.c_str(),
                     DIB_RGB_COLORS, SRCCOPY);
   } else {
     CFX_DIBitmap* pBitmap = pBitmap1;
     if (pBitmap->IsCmykImage()) {
       pBitmap = pBitmap->CloneConvert(FXDIB_Rgb);
       if (!pBitmap)
-        return FALSE;
+        return false;
     }
     int width = pSrcRect->Width(), height = pSrcRect->Height();
     LPBYTE pBuffer = pBitmap->GetBuffer();
     CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
     ::SetDIBitsToDevice(m_hDC, left, top, width, height, pSrcRect->left,
                         pBitmap->GetHeight() - pSrcRect->bottom, 0,
                         pBitmap->GetHeight(), pBuffer,
                         (BITMAPINFO*)info.c_str(), DIB_RGB_COLORS);
     if (pBitmap != pBitmap1) {
       delete pBitmap;
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CGdiDeviceDriver::GDI_StretchDIBits(CFX_DIBitmap* pBitmap1,
-                                            int dest_left,
-                                            int dest_top,
-                                            int dest_width,
-                                            int dest_height,
-                                            uint32_t flags) {
+bool CGdiDeviceDriver::GDI_StretchDIBits(CFX_DIBitmap* pBitmap1,
+                                         int dest_left,
+                                         int dest_top,
+                                         int dest_width,
+                                         int dest_height,
+                                         uint32_t flags) {
   CFX_DIBitmap* pBitmap = pBitmap1;
   if (!pBitmap || dest_width == 0 || dest_height == 0)
-    return FALSE;
+    return false;
 
   if (pBitmap->IsCmykImage() && !pBitmap->ConvertFormat(FXDIB_Rgb))
-    return FALSE;
+    return false;
 
   CFX_ByteString info = CFX_WindowsDIB::GetBitmapInfo(pBitmap);
   if ((int64_t)abs(dest_width) * abs(dest_height) <
           (int64_t)pBitmap1->GetWidth() * pBitmap1->GetHeight() * 4 ||
       (flags & FXDIB_INTERPOL) || (flags & FXDIB_BICUBIC_INTERPOL)) {
     SetStretchBltMode(m_hDC, HALFTONE);
   } else {
     SetStretchBltMode(m_hDC, COLORONCOLOR);
   }
   CFX_DIBitmap* pToStrechBitmap = pBitmap;
   bool del = false;
   if (m_DeviceClass == FXDC_PRINTER &&
       ((int64_t)pBitmap->GetWidth() * pBitmap->GetHeight() >
        (int64_t)abs(dest_width) * abs(dest_height))) {
     pToStrechBitmap = pBitmap->StretchTo(dest_width, dest_height);
     del = true;
   }
   CFX_ByteString toStrechBitmapInfo =
       CFX_WindowsDIB::GetBitmapInfo(pToStrechBitmap);
   ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height, 0, 0,
                   pToStrechBitmap->GetWidth(), pToStrechBitmap->GetHeight(),
                   pToStrechBitmap->GetBuffer(),
                   (BITMAPINFO*)toStrechBitmapInfo.c_str(), DIB_RGB_COLORS,
                   SRCCOPY);
   if (del)
     delete pToStrechBitmap;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CGdiDeviceDriver::GDI_StretchBitMask(CFX_DIBitmap* pBitmap1,
-                                             int dest_left,
-                                             int dest_top,
-                                             int dest_width,
-                                             int dest_height,
-                                             uint32_t bitmap_color,
-                                             uint32_t flags) {
+bool CGdiDeviceDriver::GDI_StretchBitMask(CFX_DIBitmap* pBitmap1,
+                                          int dest_left,
+                                          int dest_top,
+                                          int dest_width,
+                                          int dest_height,
+                                          uint32_t bitmap_color,
+                                          uint32_t flags) {
   CFX_DIBitmap* pBitmap = pBitmap1;
   if (!pBitmap || dest_width == 0 || dest_height == 0)
-    return FALSE;
+    return false;
 
   int width = pBitmap->GetWidth(), height = pBitmap->GetHeight();
   struct {
     BITMAPINFOHEADER bmiHeader;
     uint32_t bmiColors[2];
   } bmi;
   FXSYS_memset(&bmi.bmiHeader, 0, sizeof(BITMAPINFOHEADER));
   bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
   bmi.bmiHeader.biBitCount = 1;
   bmi.bmiHeader.biCompression = BI_RGB;
@@ skipping 27 matching lines @@
   // http://msdn.microsoft.com/en-us/library/aa932106.aspx, the ROP3 code is
   // 0xB8074A
 
   ::StretchDIBits(m_hDC, dest_left, dest_top, dest_width, dest_height, 0, 0,
                   width, height, pBitmap->GetBuffer(), (BITMAPINFO*)&bmi,
                   DIB_RGB_COLORS, 0xB8074A);
 
   SelectObject(m_hDC, hOld);
   DeleteObject(hPattern);
 
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CGdiDeviceDriver::GetClipBox(FX_RECT* pRect) {
+bool CGdiDeviceDriver::GetClipBox(FX_RECT* pRect) {
   return !!(::GetClipBox(m_hDC, (RECT*)pRect));
 }
 
 void* CGdiDeviceDriver::GetPlatformSurface() const {
   return (void*)m_hDC;
 }
 
 void CGdiDeviceDriver::DrawLine(FX_FLOAT x1,
                                 FX_FLOAT y1,
                                 FX_FLOAT x2,
@@ skipping 33 matching lines @@
     }
   }
   if (pMatrix) {
     pMatrix->Transform(x1, y1);
     pMatrix->Transform(x2, y2);
   }
   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr);
   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
 }
 
-FX_BOOL CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
-                                   const CFX_Matrix* pMatrix,
-                                   const CFX_GraphStateData* pGraphState,
-                                   uint32_t fill_color,
-                                   uint32_t stroke_color,
-                                   int fill_mode,
-                                   int blend_type) {
+bool CGdiDeviceDriver::DrawPath(const CFX_PathData* pPathData,
+                                const CFX_Matrix* pMatrix,
+                                const CFX_GraphStateData* pGraphState,
+                                uint32_t fill_color,
+                                uint32_t stroke_color,
+                                int fill_mode,
+                                int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL)
-    return FALSE;
+    return false;
 
   CWin32Platform* pPlatform =
       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
   if (!(pGraphState || stroke_color == 0) &&
       !pPlatform->m_GdiplusExt.IsAvailable()) {
     CFX_FloatRect bbox_f = pPathData->GetBoundingBox();
     if (pMatrix) {
       bbox_f.Transform(pMatrix);
     }
     FX_RECT bbox = bbox_f.GetInnerRect();
     if (bbox.Width() <= 0) {
       return DrawCosmeticLine(
           (FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top), (FX_FLOAT)(bbox.left),
           (FX_FLOAT)(bbox.bottom + 1), fill_color, FXDIB_BLEND_NORMAL);
     }
     if (bbox.Height() <= 0) {
       return DrawCosmeticLine((FX_FLOAT)(bbox.left), (FX_FLOAT)(bbox.top),
                               (FX_FLOAT)(bbox.right + 1), (FX_FLOAT)(bbox.top),
                               fill_color, FXDIB_BLEND_NORMAL);
     }
   }
   int fill_alpha = FXARGB_A(fill_color);
   int stroke_alpha = FXARGB_A(stroke_color);
-  FX_BOOL bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) ||
-                       (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
+  bool bDrawAlpha = (fill_alpha > 0 && fill_alpha < 255) ||
+                    (stroke_alpha > 0 && stroke_alpha < 255 && pGraphState);
   if (!pPlatform->m_GdiplusExt.IsAvailable() && bDrawAlpha)
-    return FALSE;
+    return false;
 
   if (pPlatform->m_GdiplusExt.IsAvailable()) {
     if (bDrawAlpha ||
         ((m_DeviceClass != FXDC_PRINTER && !(fill_mode & FXFILL_FULLCOVER)) ||
          (pGraphState && pGraphState->m_DashCount))) {
       if (!((!pMatrix || MatrixNoScaled(pMatrix)) && pGraphState &&
             pGraphState->m_LineWidth == 1.f &&
             (pPathData->GetPointCount() == 5 ||
              pPathData->GetPointCount() == 4) &&
             pPathData->IsRect())) {
         if (pPlatform->m_GdiplusExt.DrawPath(m_hDC, pPathData, pMatrix,
                                              pGraphState, fill_color,
                                              stroke_color, fill_mode)) {
-          return TRUE;
+          return true;
         }
       }
     }
   }
   int old_fill_mode = fill_mode;
   fill_mode &= 3;
   HPEN hPen = nullptr;
   HBRUSH hBrush = nullptr;
   if (pGraphState && stroke_alpha) {
     SetMiterLimit(m_hDC, pGraphState->m_MiterLimit, nullptr);
@@ skipping 31 matching lines @@
     }
   }
   if (hPen) {
     hPen = (HPEN)SelectObject(m_hDC, hPen);
     DeleteObject(hPen);
   }
   if (hBrush) {
     hBrush = (HBRUSH)SelectObject(m_hDC, hBrush);
     DeleteObject(hBrush);
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CGdiDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
-                                            uint32_t fill_color,
-                                            int blend_type) {
+bool CGdiDeviceDriver::FillRectWithBlend(const FX_RECT* pRect,
+                                         uint32_t fill_color,
+                                         int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL)
-    return FALSE;
+    return false;
 
   int alpha;
   FX_COLORREF rgb;
   ArgbDecode(fill_color, alpha, rgb);
   if (alpha == 0)
-    return TRUE;
+    return true;
 
   if (alpha < 255)
-    return FALSE;
+    return false;
 
   HBRUSH hBrush = CreateSolidBrush(rgb);
   ::FillRect(m_hDC, (RECT*)pRect, hBrush);
   DeleteObject(hBrush);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
-                                           const CFX_Matrix* pMatrix,
-                                           int fill_mode) {
+bool CGdiDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
+                                        const CFX_Matrix* pMatrix,
+                                        int fill_mode) {
   if (pPathData->GetPointCount() == 5) {
     CFX_FloatRect rectf;
     if (pPathData->IsRect(pMatrix, &rectf)) {
       FX_RECT rect = rectf.GetOuterRect();
       IntersectClipRect(m_hDC, rect.left, rect.top, rect.right, rect.bottom);
-      return TRUE;
+      return true;
     }
   }
   SetPathToDC(m_hDC, pPathData, pMatrix);
   SetPolyFillMode(m_hDC, fill_mode & 3);
   SelectClipPath(m_hDC, RGN_AND);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CGdiDeviceDriver::SetClip_PathStroke(
+bool CGdiDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,
     const CFX_Matrix* pMatrix,
     const CFX_GraphStateData* pGraphState) {
   HPEN hPen = CreatePen(pGraphState, pMatrix, 0xff000000);
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   SetPathToDC(m_hDC, pPathData, pMatrix);
   WidenPath(m_hDC);
   SetPolyFillMode(m_hDC, WINDING);
-  FX_BOOL ret = !!SelectClipPath(m_hDC, RGN_AND);
+  bool ret = !!SelectClipPath(m_hDC, RGN_AND);
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   DeleteObject(hPen);
   return ret;
 }
 
-FX_BOOL CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
-                                           FX_FLOAT y1,
-                                           FX_FLOAT x2,
-                                           FX_FLOAT y2,
-                                           uint32_t color,
-                                           int blend_type) {
+bool CGdiDeviceDriver::DrawCosmeticLine(FX_FLOAT x1,
+                                        FX_FLOAT y1,
+                                        FX_FLOAT x2,
+                                        FX_FLOAT y2,
+                                        uint32_t color,
+                                        int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL)
-    return FALSE;
+    return false;
 
   int a;
   FX_COLORREF rgb;
   ArgbDecode(color, a, rgb);
   if (a == 0)
-    return TRUE;
+    return true;
 
   HPEN hPen = CreatePen(PS_SOLID, 1, rgb);
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   MoveToEx(m_hDC, FXSYS_round(x1), FXSYS_round(y1), nullptr);
   LineTo(m_hDC, FXSYS_round(x2), FXSYS_round(y2));
   hPen = (HPEN)SelectObject(m_hDC, hPen);
   DeleteObject(hPen);
-  return TRUE;
+  return true;
 }
 
 CGdiDisplayDriver::CGdiDisplayDriver(HDC hDC)
     : CGdiDeviceDriver(hDC, FXDC_DISPLAY) {
   CWin32Platform* pPlatform =
       (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
   if (pPlatform->m_GdiplusExt.IsAvailable()) {
     m_RenderCaps |= FXRC_ALPHA_PATH | FXRC_ALPHA_IMAGE;
   }
 }
 
 CGdiDisplayDriver::~CGdiDisplayDriver() {}
 
-FX_BOOL CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top) {
-  FX_BOOL ret = FALSE;
+bool CGdiDisplayDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top) {
+  bool ret = false;
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   HBITMAP hbmp = CreateCompatibleBitmap(m_hDC, width, height);
   HDC hDCMemory = CreateCompatibleDC(m_hDC);
   HBITMAP holdbmp = (HBITMAP)SelectObject(hDCMemory, hbmp);
   BitBlt(hDCMemory, 0, 0, width, height, m_hDC, left, top, SRCCOPY);
   SelectObject(hDCMemory, holdbmp);
   BITMAPINFO bmi;
   FXSYS_memset(&bmi, 0, sizeof bmi);
   bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;
   bmi.bmiHeader.biBitCount = pBitmap->GetBPP();
   bmi.bmiHeader.biHeight = -height;
   bmi.bmiHeader.biPlanes = 1;
   bmi.bmiHeader.biWidth = width;
   if (pBitmap->GetBPP() > 8 && !pBitmap->IsCmykImage()) {
     ret = ::GetDIBits(hDCMemory, hbmp, 0, height, pBitmap->GetBuffer(), &bmi,
                       DIB_RGB_COLORS) == height;
   } else {
     CFX_DIBitmap bitmap;
     if (bitmap.Create(width, height, FXDIB_Rgb)) {
       bmi.bmiHeader.biBitCount = 24;
       ::GetDIBits(hDCMemory, hbmp, 0, height, bitmap.GetBuffer(), &bmi,
                   DIB_RGB_COLORS);
       ret = pBitmap->TransferBitmap(0, 0, width, height, &bitmap, 0, 0);
     } else {
-      ret = FALSE;
+      ret = false;
     }
   }
   if (pBitmap->HasAlpha() && ret)
     pBitmap->LoadChannel(FXDIB_Alpha, 0xff);
 
   DeleteObject(hbmp);
   DeleteObject(hDCMemory);
   return ret;
 }
 
-FX_BOOL CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource,
-                                     uint32_t color,
-                                     const FX_RECT* pSrcRect,
-                                     int left,
-                                     int top,
-                                     int blend_type) {
+bool CGdiDisplayDriver::SetDIBits(const CFX_DIBSource* pSource,
+                                  uint32_t color,
+                                  const FX_RECT* pSrcRect,
+                                  int left,
+                                  int top,
+                                  int blend_type) {
   ASSERT(blend_type == FXDIB_BLEND_NORMAL);
   if (pSource->IsAlphaMask()) {
     int width = pSource->GetWidth(), height = pSource->GetHeight();
     int alpha = FXARGB_A(color);
     if (pSource->GetBPP() != 1 || alpha != 255) {
       CFX_DIBitmap background;
       if (!background.Create(width, height, FXDIB_Rgb32) ||
           !GetDIBits(&background, left, top) ||
           !background.CompositeMask(0, 0, width, height, pSource, color, 0, 0,
-                                    FXDIB_BLEND_NORMAL, nullptr, FALSE, 0,
+                                    FXDIB_BLEND_NORMAL, nullptr, false, 0,
                                     nullptr)) {
-        return FALSE;
+        return false;
       }
       FX_RECT src_rect(0, 0, width, height);
       return SetDIBits(&background, 0, &src_rect, left, top,
                        FXDIB_BLEND_NORMAL);
     }
     FX_RECT clip_rect(left, top, left + pSrcRect->Width(),
                       top + pSrcRect->Height());
     return StretchDIBits(pSource, color, left - pSrcRect->left,
                          top - pSrcRect->top, width, height, &clip_rect, 0,
                          FXDIB_BLEND_NORMAL);
   }
   int width = pSrcRect->Width(), height = pSrcRect->Height();
   if (pSource->HasAlpha()) {
     CFX_DIBitmap bitmap;
     if (!bitmap.Create(width, height, FXDIB_Rgb) ||
         !GetDIBits(&bitmap, left, top) ||
         !bitmap.CompositeBitmap(0, 0, width, height, pSource, pSrcRect->left,
                                 pSrcRect->top, FXDIB_BLEND_NORMAL, nullptr,
-                                FALSE, nullptr)) {
-      return FALSE;
+                                false, nullptr)) {
+      return false;
     }
     FX_RECT src_rect(0, 0, width, height);
     return SetDIBits(&bitmap, 0, &src_rect, left, top, FXDIB_BLEND_NORMAL);
   }
   CFX_DIBExtractor temp(pSource);
   CFX_DIBitmap* pBitmap = temp.GetBitmap();
   if (!pBitmap)
-    return FALSE;
+    return false;
   return GDI_SetDIBits(pBitmap, pSrcRect, left, top);
 }
 
-FX_BOOL CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource,
-                                                 uint32_t color,
-                                                 int dest_left,
-                                                 int dest_top,
-                                                 int dest_width,
-                                                 int dest_height,
-                                                 const FX_RECT* pClipRect,
-                                                 int render_flags) {
+bool CGdiDisplayDriver::UseFoxitStretchEngine(const CFX_DIBSource* pSource,
+                                              uint32_t color,
+                                              int dest_left,
+                                              int dest_top,
+                                              int dest_width,
+                                              int dest_height,
+                                              const FX_RECT* pClipRect,
+                                              int render_flags) {
   FX_RECT bitmap_clip = *pClipRect;
   if (dest_width < 0)
     dest_left += dest_width;
 
   if (dest_height < 0)
     dest_top += dest_height;
 
   bitmap_clip.Offset(-dest_left, -dest_top);
   std::unique_ptr<CFX_DIBitmap> pStretched(
       pSource->StretchTo(dest_width, dest_height, render_flags, &bitmap_clip));
   if (!pStretched)
-    return TRUE;
+    return true;
 
   FX_RECT src_rect(0, 0, pStretched->GetWidth(), pStretched->GetHeight());
   return SetDIBits(pStretched.get(), color, &src_rect, pClipRect->left,
                    pClipRect->top, FXDIB_BLEND_NORMAL);
 }
 
-FX_BOOL CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource,
-                                         uint32_t color,
-                                         int dest_left,
-                                         int dest_top,
-                                         int dest_width,
-                                         int dest_height,
-                                         const FX_RECT* pClipRect,
-                                         uint32_t flags,
-                                         int blend_type) {
+bool CGdiDisplayDriver::StretchDIBits(const CFX_DIBSource* pSource,
+                                      uint32_t color,
+                                      int dest_left,
+                                      int dest_top,
+                                      int dest_width,
+                                      int dest_height,
+                                      const FX_RECT* pClipRect,
+                                      uint32_t flags,
+                                      int blend_type) {
   ASSERT(pSource && pClipRect);
   if (flags || dest_width > 10000 || dest_width < -10000 ||
       dest_height > 10000 || dest_height < -10000) {
     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
                                  dest_width, dest_height, pClipRect, flags);
   }
   if (pSource->IsAlphaMask()) {
     FX_RECT image_rect;
     image_rect.left = dest_width > 0 ? dest_left : dest_left + dest_width;
     image_rect.right = dest_width > 0 ? dest_left + dest_width : dest_left;
     image_rect.top = dest_height > 0 ? dest_top : dest_top + dest_height;
     image_rect.bottom = dest_height > 0 ? dest_top + dest_height : dest_top;
     FX_RECT clip_rect = image_rect;
     clip_rect.Intersect(*pClipRect);
     clip_rect.Offset(-image_rect.left, -image_rect.top);
     int clip_width = clip_rect.Width(), clip_height = clip_rect.Height();
     std::unique_ptr<CFX_DIBitmap> pStretched(
         pSource->StretchTo(dest_width, dest_height, flags, &clip_rect));
     if (!pStretched)
-      return TRUE;
+      return true;
 
     CFX_DIBitmap background;
     if (!background.Create(clip_width, clip_height, FXDIB_Rgb32) ||
         !GetDIBits(&background, image_rect.left + clip_rect.left,
                    image_rect.top + clip_rect.top) ||
         !background.CompositeMask(
             0, 0, clip_width, clip_height, pStretched.get(), color, 0, 0,
-            FXDIB_BLEND_NORMAL, nullptr, FALSE, 0, nullptr)) {
-      return FALSE;
+            FXDIB_BLEND_NORMAL, nullptr, false, 0, nullptr)) {
+      return false;
     }
 
     FX_RECT src_rect(0, 0, clip_width, clip_height);
     return SetDIBits(&background, 0, &src_rect,
                      image_rect.left + clip_rect.left,
                      image_rect.top + clip_rect.top, FXDIB_BLEND_NORMAL);
   }
   if (pSource->HasAlpha()) {
     CWin32Platform* pPlatform =
         (CWin32Platform*)CFX_GEModule::Get()->GetPlatformData();
     if (pPlatform->m_GdiplusExt.IsAvailable() && !pSource->IsCmykImage()) {
       CFX_DIBExtractor temp(pSource);
       CFX_DIBitmap* pBitmap = temp.GetBitmap();
       if (!pBitmap)
-        return FALSE;
+        return false;
       return pPlatform->m_GdiplusExt.StretchDIBits(
           m_hDC, pBitmap, dest_left, dest_top, dest_width, dest_height,
           pClipRect, flags);
     }
     return UseFoxitStretchEngine(pSource, color, dest_left, dest_top,
                                  dest_width, dest_height, pClipRect, flags);
   }
   CFX_DIBExtractor temp(pSource);
   CFX_DIBitmap* pBitmap = temp.GetBitmap();
   if (!pBitmap)
-    return FALSE;
+    return false;
   return GDI_StretchDIBits(pBitmap, dest_left, dest_top, dest_width,
                            dest_height, flags);
 }
 
-FX_BOOL CGdiDisplayDriver::StartDIBits(const CFX_DIBSource* pBitmap,
-                                       int bitmap_alpha,
-                                       uint32_t color,
-                                       const CFX_Matrix* pMatrix,
-                                       uint32_t render_flags,
-                                       void*& handle,
-                                       int blend_type) {
-  return FALSE;
+bool CGdiDisplayDriver::StartDIBits(const CFX_DIBSource* pBitmap,
+                                    int bitmap_alpha,
+                                    uint32_t color,
+                                    const CFX_Matrix* pMatrix,
+                                    uint32_t render_flags,
+                                    void*& handle,
+                                    int blend_type) {
+  return false;
 }
 
 CFX_WindowsDevice::CFX_WindowsDevice(HDC hDC) {
   SetDeviceDriver(pdfium::WrapUnique(CreateDriver(hDC)));
 }
 
 CFX_WindowsDevice::~CFX_WindowsDevice() {}
 
 HDC CFX_WindowsDevice::GetDC() const {
   IFX_RenderDeviceDriver* pRDD = GetDeviceDriver();
   return pRDD ? reinterpret_cast<HDC>(pRDD->GetPlatformSurface()) : nullptr;
 }
 
 // static
 IFX_RenderDeviceDriver* CFX_WindowsDevice::CreateDriver(HDC hDC) {
   int device_type = ::GetDeviceCaps(hDC, TECHNOLOGY);
   int obj_type = ::GetObjectType(hDC);
   bool use_printer = device_type == DT_RASPRINTER ||
                      device_type == DT_PLOTTER || obj_type == OBJ_ENHMETADC;
   if (use_printer)
     return new CGdiPrinterDriver(hDC);
   return new CGdiDisplayDriver(hDC);
 }