Remove FX_BOOL from core

core/fxge/win32/fx_win32_gdipext.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 <windows.h>
 
 #include <algorithm>
 
@@ skipping 428 matching lines @@
                                            uint32_t size,
                                            void* pdv,
                                            uint32_t* num_face) {
   if (!m_pGdiAddFontMemResourceEx)
     return nullptr;
 
   return m_pGdiAddFontMemResourceEx((PVOID)pFontdata, (DWORD)size, (PVOID)pdv,
                                     (DWORD*)num_face);
 }
 
-FX_BOOL CGdiplusExt::GdiRemoveFontMemResourceEx(void* handle) {
+bool CGdiplusExt::GdiRemoveFontMemResourceEx(void* handle) {
   return m_pGdiRemoveFontMemResourseEx &&
          m_pGdiRemoveFontMemResourseEx((HANDLE)handle);
 }
 
 static GpBrush* _GdipCreateBrush(DWORD argb) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpSolidFill* solidBrush = nullptr;
   CallFunc(GdipCreateSolidFill)((ARGB)argb, &solidBrush);
   return solidBrush;
 }
 static CFX_DIBitmap* _StretchMonoToGray(int dest_width,
                                         int dest_height,
                                         const CFX_DIBitmap* pSource,
                                         FX_RECT* pClipRect) {
-  FX_BOOL bFlipX = dest_width < 0;
+  bool bFlipX = dest_width < 0;
   if (bFlipX) {
     dest_width = -dest_width;
   }
-  FX_BOOL bFlipY = dest_height < 0;
+  bool bFlipY = dest_height < 0;
   if (bFlipY) {
     dest_height = -dest_height;
   }
   int result_width = pClipRect->Width();
   int result_height = pClipRect->Height();
   int result_pitch = (result_width + 3) / 4 * 4;
   CFX_DIBitmap* pStretched = new CFX_DIBitmap;
   if (!pStretched->Create(result_width, result_height, FXDIB_8bppRgb)) {
     delete pStretched;
     return nullptr;
@@ skipping 77 matching lines @@
     if (image_clip.IsEmpty()) {
       return;
     }
     image_clip.Offset(-image_rect.left, -image_rect.top);
     CFX_DIBitmap* pStretched = nullptr;
     if (src_width * src_height > 10000) {
       pStretched =
           _StretchMonoToGray(dest_width, dest_height, pBitmap, &image_clip);
     } else {
       pStretched =
-          pBitmap->StretchTo(dest_width, dest_height, FALSE, &image_clip);
+          pBitmap->StretchTo(dest_width, dest_height, false, &image_clip);
     }
     GpBitmap* bitmap;
     CallFunc(GdipCreateBitmapFromScan0)(image_clip.Width(), image_clip.Height(),
                                         (image_clip.Width() + 3) / 4 * 4,
                                         PixelFormat8bppIndexed,
                                         pStretched->GetBuffer(), &bitmap);
     int a, r, g, b;
     ArgbDecode(argb, a, r, g, b);
     UINT pal[258];
     pal[0] = 0;
@@ skipping 144 matching lines @@
     return pCollection;
   }
   CallFunc(GdipDeletePrivateFontCollection)(&pCollection);
   return nullptr;
 }
 void CGdiplusExt::DeleteMemFont(LPVOID pCollection) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipDeletePrivateFontCollection)((GpFontCollection**)&pCollection);
 }
-FX_BOOL CGdiplusExt::GdipCreateBitmap(CFX_DIBitmap* pBitmap, void** bitmap) {
+bool CGdiplusExt::GdipCreateBitmap(CFX_DIBitmap* pBitmap, void** bitmap) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   PixelFormat format;
   switch (pBitmap->GetFormat()) {
     case FXDIB_Rgb:
       format = PixelFormat24bppRGB;
       break;
     case FXDIB_Rgb32:
       format = PixelFormat32bppRGB;
       break;
     case FXDIB_Argb:
       format = PixelFormat32bppARGB;
       break;
     default:
-      return FALSE;
+      return false;
   }
   GpStatus status = CallFunc(GdipCreateBitmapFromScan0)(
       pBitmap->GetWidth(), pBitmap->GetHeight(), pBitmap->GetPitch(), format,
       pBitmap->GetBuffer(), (GpBitmap**)bitmap);
   if (status == Ok) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CGdiplusExt::GdipCreateFromImage(void* bitmap, void** graphics) {
+bool CGdiplusExt::GdipCreateFromImage(void* bitmap, void** graphics) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpStatus status = CallFunc(GdipGetImageGraphicsContext)(
       (GpBitmap*)bitmap, (GpGraphics**)graphics);
   if (status == Ok) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CGdiplusExt::GdipCreateFontFamilyFromName(const FX_WCHAR* name,
-                                                  void* pFontCollection,
-                                                  void** pFamily) {
+bool CGdiplusExt::GdipCreateFontFamilyFromName(const FX_WCHAR* name,
+                                               void* pFontCollection,
+                                               void** pFamily) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpStatus status = CallFunc(GdipCreateFontFamilyFromName)(
       (GDIPCONST WCHAR*)name, (GpFontCollection*)pFontCollection,
       (GpFontFamily**)pFamily);
   if (status == Ok) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CGdiplusExt::GdipCreateFontFromFamily(void* pFamily,
-                                              FX_FLOAT font_size,
-                                              int fontstyle,
-                                              int flag,
-                                              void** pFont) {
+bool CGdiplusExt::GdipCreateFontFromFamily(void* pFamily,
+                                           FX_FLOAT font_size,
+                                           int fontstyle,
+                                           int flag,
+                                           void** pFont) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpStatus status =
       CallFunc(GdipCreateFont)((GpFontFamily*)pFamily, font_size, fontstyle,
                                Unit(flag), (GpFont**)pFont);
   if (status == Ok) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 void CGdiplusExt::GdipGetFontSize(void* pFont, FX_FLOAT* size) {
   REAL get_size;
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpStatus status = CallFunc(GdipGetFontSize)((GpFont*)pFont, (REAL*)&get_size);
   if (status == Ok) {
     *size = (FX_FLOAT)get_size;
   } else {
     *size = 0;
   }
 }
 void CGdiplusExt::GdipSetTextRenderingHint(void* graphics, int mode) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipSetTextRenderingHint)((GpGraphics*)graphics,
                                      (TextRenderingHint)mode);
 }
 void CGdiplusExt::GdipSetPageUnit(void* graphics, uint32_t unit) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipSetPageUnit)((GpGraphics*)graphics, (GpUnit)unit);
 }
-FX_BOOL CGdiplusExt::GdipDrawDriverString(void* graphics,
-                                          unsigned short* text,
-                                          int length,
-                                          void* font,
-                                          void* brush,
-                                          void* positions,
-                                          int flags,
-                                          const void* matrix) {
+bool CGdiplusExt::GdipDrawDriverString(void* graphics,
+                                       unsigned short* text,
+                                       int length,
+                                       void* font,
+                                       void* brush,
+                                       void* positions,
+                                       int flags,
+                                       const void* matrix) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpStatus status = CallFunc(GdipDrawDriverString)(
       (GpGraphics*)graphics, (GDIPCONST UINT16*)text, (INT)length,
       (GDIPCONST GpFont*)font, (GDIPCONST GpBrush*)brush,
       (GDIPCONST PointF*)positions, (INT)flags, (GDIPCONST GpMatrix*)matrix);
   if (status == Ok) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 void CGdiplusExt::GdipCreateBrush(uint32_t fill_argb, void** pBrush) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipCreateSolidFill)((ARGB)fill_argb, (GpSolidFill**)pBrush);
 }
 void CGdiplusExt::GdipDeleteBrush(void* pBrush) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipDeleteBrush)((GpSolidFill*)pBrush);
@@ skipping 57 matching lines @@
 void CGdiplusExt::GdipDisposeImage(void* bitmap) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipDisposeImage)((GpBitmap*)bitmap);
 }
 void CGdiplusExt::GdipDeleteGraphics(void* graphics) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipDeleteGraphics)((GpGraphics*)graphics);
 }
-FX_BOOL CGdiplusExt::StretchBitMask(HDC hDC,
-                                    BOOL bMonoDevice,
-                                    const CFX_DIBitmap* pBitmap,
-                                    int dest_left,
-                                    int dest_top,
-                                    int dest_width,
-                                    int dest_height,
-                                    uint32_t argb,
-                                    const FX_RECT* pClipRect,
-                                    int flags) {
+bool CGdiplusExt::StretchBitMask(HDC hDC,
+                                 BOOL bMonoDevice,
+                                 const CFX_DIBitmap* pBitmap,
+                                 int dest_left,
+                                 int dest_top,
+                                 int dest_width,
+                                 int dest_height,
+                                 uint32_t argb,
+                                 const FX_RECT* pClipRect,
+                                 int flags) {
   ASSERT(pBitmap->GetBPP() == 1);
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpGraphics* pGraphics = nullptr;
   CallFunc(GdipCreateFromHDC)(hDC, &pGraphics);
   CallFunc(GdipSetPageUnit)(pGraphics, UnitPixel);
   if (flags & FXDIB_NOSMOOTH) {
     CallFunc(GdipSetInterpolationMode)(pGraphics,
                                        InterpolationModeNearestNeighbor);
   } else {
     CallFunc(GdipSetInterpolationMode)(pGraphics, InterpolationModeHighQuality);
   }
   OutputImageMask(pGraphics, bMonoDevice, pBitmap, dest_left, dest_top,
                   dest_width, dest_height, argb, pClipRect);
   CallFunc(GdipDeleteGraphics)(pGraphics);
-  return TRUE;
+  return true;
 }
-FX_BOOL CGdiplusExt::StretchDIBits(HDC hDC,
-                                   const CFX_DIBitmap* pBitmap,
-                                   int dest_left,
-                                   int dest_top,
-                                   int dest_width,
-                                   int dest_height,
-                                   const FX_RECT* pClipRect,
-                                   int flags) {
+bool CGdiplusExt::StretchDIBits(HDC hDC,
+                                const CFX_DIBitmap* pBitmap,
+                                int dest_left,
+                                int dest_top,
+                                int dest_width,
+                                int dest_height,
+                                const FX_RECT* pClipRect,
+                                int flags) {
   GpGraphics* pGraphics;
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipCreateFromHDC)(hDC, &pGraphics);
   CallFunc(GdipSetPageUnit)(pGraphics, UnitPixel);
   if (flags & FXDIB_NOSMOOTH) {
     CallFunc(GdipSetInterpolationMode)(pGraphics,
                                        InterpolationModeNearestNeighbor);
   } else if (pBitmap->GetWidth() > abs(dest_width) / 2 ||
              pBitmap->GetHeight() > abs(dest_height) / 2) {
     CallFunc(GdipSetInterpolationMode)(pGraphics, InterpolationModeHighQuality);
   } else {
     CallFunc(GdipSetInterpolationMode)(pGraphics, InterpolationModeBilinear);
   }
   FX_RECT src_rect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
   OutputImage(pGraphics, pBitmap, &src_rect, dest_left, dest_top, dest_width,
               dest_height);
   CallFunc(GdipDeleteGraphics)(pGraphics);
   CallFunc(GdipDeleteGraphics)(pGraphics);
-  return TRUE;
+  return true;
 }
 static GpPen* _GdipCreatePen(const CFX_GraphStateData* pGraphState,
                              const CFX_Matrix* pMatrix,
                              DWORD argb,
-                             FX_BOOL bTextMode = FALSE) {
+                             bool bTextMode = false) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   FX_FLOAT width = pGraphState ? pGraphState->m_LineWidth : 1.0f;
   if (!bTextMode) {
     FX_FLOAT unit =
         pMatrix ? 1.0f / ((pMatrix->GetXUnit() + pMatrix->GetYUnit()) / 2)
                 : 1.0f;
     if (width < unit) {
       width = unit;
     }
   }
   GpPen* pPen = nullptr;
   CallFunc(GdipCreatePen1)((ARGB)argb, width, UnitWorld, &pPen);
   LineCap lineCap = LineCapFlat;
   DashCap dashCap = DashCapFlat;
-  FX_BOOL bDashExtend = FALSE;
+  bool bDashExtend = false;
   switch (pGraphState->m_LineCap) {
     case CFX_GraphStateData::LineCapButt:
       lineCap = LineCapFlat;
       break;
     case CFX_GraphStateData::LineCapRound:
       lineCap = LineCapRound;
       dashCap = DashCapRound;
-      bDashExtend = TRUE;
+      bDashExtend = true;
       break;
     case CFX_GraphStateData::LineCapSquare:
       lineCap = LineCapSquare;
-      bDashExtend = TRUE;
+      bDashExtend = true;
       break;
   }
   CallFunc(GdipSetPenLineCap197819)(pPen, lineCap, lineCap, dashCap);
   LineJoin lineJoin = LineJoinMiterClipped;
   switch (pGraphState->m_LineJoin) {
     case CFX_GraphStateData::LineJoinMiter:
       lineJoin = LineJoinMiterClipped;
       break;
     case CFX_GraphStateData::LineJoinRound:
       lineJoin = LineJoinRound;
@@ skipping 54 matching lines @@
         phase -= 0.5f;
       }
     }
     CallFunc(GdipSetPenDashOffset)(pPen, phase);
     FX_Free(pDashArray);
     pDashArray = nullptr;
   }
   CallFunc(GdipSetPenMiterLimit)(pPen, pGraphState->m_MiterLimit);
   return pPen;
 }
-static FX_BOOL IsSmallTriangle(PointF* points,
-                               const CFX_Matrix* pMatrix,
-                               int& v1,
-                               int& v2) {
+static bool IsSmallTriangle(PointF* points,
+                            const CFX_Matrix* pMatrix,
+                            int& v1,
+                            int& v2) {
   int pairs[] = {1, 2, 0, 2, 0, 1};
   for (int i = 0; i < 3; i++) {
     int pair1 = pairs[i * 2];
     int pair2 = pairs[i * 2 + 1];
     FX_FLOAT x1 = points[pair1].X, x2 = points[pair2].X;
     FX_FLOAT y1 = points[pair1].Y, y2 = points[pair2].Y;
     if (pMatrix) {
       pMatrix->Transform(x1, y1);
       pMatrix->Transform(x2, y2);
     }
     FX_FLOAT dx = x1 - x2;
     FX_FLOAT dy = y1 - y2;
     FX_FLOAT distance_square = (dx * dx) + (dy * dy);
     if (distance_square < (1.0f * 2 + 1.0f / 4)) {
       v1 = i;
       v2 = pair1;
-      return TRUE;
+      return true;
     }
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CGdiplusExt::DrawPath(HDC hDC,
-                              const CFX_PathData* pPathData,
-                              const CFX_Matrix* pObject2Device,
-                              const CFX_GraphStateData* pGraphState,
-                              uint32_t fill_argb,
-                              uint32_t stroke_argb,
-                              int fill_mode) {
+bool CGdiplusExt::DrawPath(HDC hDC,
+                           const CFX_PathData* pPathData,
+                           const CFX_Matrix* pObject2Device,
+                           const CFX_GraphStateData* pGraphState,
+                           uint32_t fill_argb,
+                           uint32_t stroke_argb,
+                           int fill_mode) {
   int nPoints = pPathData->GetPointCount();
   if (nPoints == 0) {
-    return TRUE;
+    return true;
   }
   FX_PATHPOINT* pPoints = pPathData->GetPoints();
   GpGraphics* pGraphics = nullptr;
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   CallFunc(GdipCreateFromHDC)(hDC, &pGraphics);
   CallFunc(GdipSetPageUnit)(pGraphics, UnitPixel);
   CallFunc(GdipSetPixelOffsetMode)(pGraphics, PixelOffsetModeHalf);
   GpMatrix* pMatrix = nullptr;
   if (pObject2Device) {
     CallFunc(GdipCreateMatrix2)(pObject2Device->a, pObject2Device->b,
                                 pObject2Device->c, pObject2Device->d,
                                 pObject2Device->e, pObject2Device->f, &pMatrix);
     CallFunc(GdipSetWorldTransform)(pGraphics, pMatrix);
   }
   PointF* points = FX_Alloc(PointF, nPoints);
   BYTE* types = FX_Alloc(BYTE, nPoints);
   int nSubPathes = 0;
-  FX_BOOL bSubClose = FALSE;
+  bool bSubClose = false;
   int pos_subclose = 0;
-  FX_BOOL bSmooth = FALSE;
+  bool bSmooth = false;
   int startpoint = 0;
   for (int i = 0; i < nPoints; i++) {
     points[i].X = pPoints[i].m_PointX;
     points[i].Y = pPoints[i].m_PointY;
     FX_FLOAT x, y;
     if (pObject2Device) {
       pObject2Device->Transform(pPoints[i].m_PointX, pPoints[i].m_PointY, x, y);
     } else {
       x = pPoints[i].m_PointX;
       y = pPoints[i].m_PointY;
     }
     if (x > 50000 * 1.0f) {
       points[i].X = 50000 * 1.0f;
     }
     if (x < -50000 * 1.0f) {
       points[i].X = -50000 * 1.0f;
     }
     if (y > 50000 * 1.0f) {
       points[i].Y = 50000 * 1.0f;
     }
     if (y < -50000 * 1.0f) {
       points[i].Y = -50000 * 1.0f;
     }
     int point_type = pPoints[i].m_Flag & FXPT_TYPE;
     if (point_type == FXPT_MOVETO) {
       types[i] = PathPointTypeStart;
       nSubPathes++;
-      bSubClose = FALSE;
+      bSubClose = false;
       startpoint = i;
     } else if (point_type == FXPT_LINETO) {
       types[i] = PathPointTypeLine;
       if (pPoints[i - 1].m_Flag == FXPT_MOVETO &&
           (i == nPoints - 1 || pPoints[i + 1].m_Flag == FXPT_MOVETO) &&
           points[i].Y == points[i - 1].Y && points[i].X == points[i - 1].X) {
         points[i].X += 0.01f;
         continue;
       }
       if (!bSmooth && points[i].X != points[i - 1].X &&
           points[i].Y != points[i - 1].Y) {
-        bSmooth = TRUE;
+        bSmooth = true;
       }
     } else if (point_type == FXPT_BEZIERTO) {
       types[i] = PathPointTypeBezier;
-      bSmooth = TRUE;
+      bSmooth = true;
     }
     if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) {
       if (bSubClose) {
         types[pos_subclose] &= ~PathPointTypeCloseSubpath;
       } else {
-        bSubClose = TRUE;
+        bSubClose = true;
       }
       pos_subclose = i;
       types[i] |= PathPointTypeCloseSubpath;
       if (!bSmooth && points[i].X != points[startpoint].X &&
           points[i].Y != points[startpoint].Y) {
-        bSmooth = TRUE;
+        bSmooth = true;
       }
     }
   }
   if (fill_mode & FXFILL_NOPATHSMOOTH) {
-    bSmooth = FALSE;
+    bSmooth = false;
     CallFunc(GdipSetSmoothingMode)(pGraphics, SmoothingModeNone);
   } else if (!(fill_mode & FXFILL_FULLCOVER)) {
     if (!bSmooth && (fill_mode & 3)) {
-      bSmooth = TRUE;
+      bSmooth = true;
     }
     if (bSmooth || (pGraphState && pGraphState->m_LineWidth > 2)) {
       CallFunc(GdipSetSmoothingMode)(pGraphics, SmoothingModeAntiAlias);
     }
   }
   int new_fill_mode = fill_mode & 3;
   if (nPoints == 4 && !pGraphState) {
     int v1, v2;
     if (IsSmallTriangle(points, pObject2Device, v1, v2)) {
       GpPen* pPen = nullptr;
       CallFunc(GdipCreatePen1)(fill_argb, 1.0f, UnitPixel, &pPen);
       CallFunc(GdipDrawLineI)(
           pGraphics, pPen, FXSYS_round(points[v1].X), FXSYS_round(points[v1].Y),
           FXSYS_round(points[v2].X), FXSYS_round(points[v2].Y));
       CallFunc(GdipDeletePen)(pPen);
-      return TRUE;
+      return true;
     }
   }
   GpPath* pGpPath = nullptr;
   CallFunc(GdipCreatePath2)(points, types, nPoints,
                             GdiFillType2Gdip(new_fill_mode), &pGpPath);
   if (!pGpPath) {
     if (pMatrix) {
       CallFunc(GdipDeleteMatrix)(pMatrix);
     }
     FX_Free(points);
     FX_Free(types);
     CallFunc(GdipDeleteGraphics)(pGraphics);
-    return FALSE;
+    return false;
   }
   if (new_fill_mode) {
     GpBrush* pBrush = _GdipCreateBrush(fill_argb);
     CallFunc(GdipSetPathFillMode)(pGpPath, GdiFillType2Gdip(new_fill_mode));
     CallFunc(GdipFillPath)(pGraphics, pBrush, pGpPath);
     CallFunc(GdipDeleteBrush)(pBrush);
   }
   if (pGraphState && stroke_argb) {
     GpPen* pPen = _GdipCreatePen(pGraphState, pObject2Device, stroke_argb,
                                  !!(fill_mode & FX_STROKE_TEXT_MODE));
@@ skipping 15 matching lines @@
     }
     CallFunc(GdipDeletePen)(pPen);
   }
   if (pMatrix) {
     CallFunc(GdipDeleteMatrix)(pMatrix);
   }
   FX_Free(points);
   FX_Free(types);
   CallFunc(GdipDeletePath)(pGpPath);
   CallFunc(GdipDeleteGraphics)(pGraphics);
-  return TRUE;
+  return true;
 }
 
 class GpStream final : public IStream {
  public:
   GpStream() : m_RefCount(1), m_ReadPos(0) {}
 
   // IUnknown
   HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid,
                                            void** ppvObject) override {
     if (iid == __uuidof(IUnknown) || iid == __uuidof(IStream) ||
@@ skipping 220 matching lines @@
   FX_Free(pInfo->pBitmapData);
   FX_Free((LPBYTE)pInfo->pbmi);
   if (pInfo->pStream) {
     pInfo->pStream->Release();
   }
   FX_Free(pInfo);
 }
 
 CFX_DIBitmap* _FX_WindowsDIB_LoadFromBuf(BITMAPINFO* pbmi,
                                          LPVOID pData,
-                                         FX_BOOL bAlpha);
+                                         bool bAlpha);
 CFX_DIBitmap* CGdiplusExt::LoadDIBitmap(WINDIB_Open_Args_ args) {
   PREVIEW3_DIBITMAP* pInfo = ::LoadDIBitmap(args);
   if (!pInfo) {
     return nullptr;
   }
   int height = abs(pInfo->pbmi->bmiHeader.biHeight);
   int width = pInfo->pbmi->bmiHeader.biWidth;
   int dest_pitch = (width * pInfo->pbmi->bmiHeader.biBitCount + 31) / 32 * 4;
   LPBYTE pData = FX_Alloc2D(BYTE, dest_pitch, height);
   if (dest_pitch == pInfo->Stride) {
     FXSYS_memcpy(pData, pInfo->pScan0, dest_pitch * height);
   } else {
     for (int i = 0; i < height; i++) {
       FXSYS_memcpy(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i,
                    dest_pitch);
     }
   }
   CFX_DIBitmap* pDIBitmap = _FX_WindowsDIB_LoadFromBuf(
       pInfo->pbmi, pData, pInfo->pbmi->bmiHeader.biBitCount == 32);
   FX_Free(pData);
   FreeDIBitmap(pInfo);
   return pDIBitmap;
 }