FX_BOOL considered harmful.

core/src/fxge/skia/fx_skia_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.
 
 #include "../../../include/fxge/fx_ge.h"
 //#define _SKIA_SUPPORT_
 #if defined(_SKIA_SUPPORT_)
 #include "../../../include/fxcodec/fx_codec.h"
 
 
@@ skipping 28 matching lines @@
 
 #include "fx_skia_blitter_new.h"
 #include "../agg/fx_agg_driver.h"
 #include "fx_skia_device.h"
 /// Run-length-encoded supersampling antialiased blitter.
 class SuperBlitter_skia
 {
 public:
         static void DrawPath(const SkPath& srcPath, SkBlitter* blitter,  const SkRasterClip& rect, const SkPaint& origPaint);
 };
-FX_BOOL FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) {
+bool FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) {
         if (SkPaint::kStroke_Style != paint.getStyle())
-                return FALSE;
+                return false;
         FXSYS_assert(coverage);
         SkScalar strokeWidth = paint.getStrokeWidth();
         if (0 == strokeWidth) {
                 *coverage = SK_Scalar1;
-                return TRUE;
+                return true;
         }
         // if we get here, we need to try to fake a thick-stroke with a modulated
         // hairline
         if (!paint.isAntiAlias())
-                return FALSE;
+                return false;
         if (strokeWidth <= SK_Scalar1) {
                 *coverage = strokeWidth;
-                return TRUE;
+                return true;
         }
-        return FALSE;
+        return false;
 }
 
 void SuperBlitter_skia::DrawPath(const SkPath& srcPath, SkBlitter* blitter, const SkRasterClip& rect, const SkPaint& origPaint)
 {
         SkPath*         pathPtr = (SkPath*)&srcPath;
         bool            doFill = true;
         SkPath          tmpPath;
         SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
         {
                 SkScalar coverage;
@@ skipping 83 matching lines @@
                         i += 2;
                 }
                 if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) m_PathData.close();
         }
 }
 
 // convert a stroking path to scanlines
 static void SkRasterizeStroke(SkPaint& spaint, SkPath* dstPathData, SkPath& path_data,
                                          const CFX_AffineMatrix* pObject2Device,
                                          const CFX_GraphStateData* pGraphState, FX_FIXFLOAT scale = FIX8_ONE,
-                                         FX_BOOL bStrokeAdjust = FALSE, FX_BOOL bTextMode = FALSE)
+                                         bool bStrokeAdjust = false, bool bTextMode = false)
 {
         SkPaint::Cap cap;
         switch (pGraphState->m_LineCap) {
                 case CFX_GraphStateData::LineCapRound:
                         cap = SkPaint::kRound_Cap;
                         break;
                 case CFX_GraphStateData::LineCapSquare:
                         cap = SkPaint::kSquare_Cap;
                         break;
                 default:
@@ skipping 15 matching lines @@
         FX_FIXFLOAT width = pGraphState->m_LineWidth*scale;
         FX_FIXFLOAT unit = fix32_to_8(fixdiv_8_8_to_32(FIX8_ONE, (pObject2Device->GetXUnit() + pObject2Device->GetYUnit()) / 2));
         if (width <= unit) width = unit;
 
         if (pGraphState->m_DashArray == NULL) {
                 SkStroke stroker;
                 stroker.setCap(cap);
                 stroker.setJoin(join);
                 stroker.setMiterLimit(pGraphState->m_MiterLimit);
                 stroker.setWidth(width);
-                stroker.setDoFill(FALSE);
+                stroker.setDoFill(false);
                 stroker.strokePath(path_data, dstPathData);
                 SkMatrix smatrix;
                 smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1);
                 dstPathData->transform(smatrix);
         } else {
                 int count = (pGraphState->m_DashCount+1)/2;
                 SkScalar* intervals = FX_Alloc2D(SkScalar, count, sizeof(SkScalar));
                 // Set dash pattern
                 for (int i = 0; i < count; i ++) {
                         FX_FIXFLOAT on = pGraphState->m_DashArray[i*2];
@@ skipping 11 matching lines @@
                 spaint.setStrokeCap(cap);
                 spaint.setStrokeJoin(join);
                 spaint.getFillPath(path_data, dstPathData);
                 SkMatrix smatrix;
                 smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Device->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1);
                 dstPathData->transform(smatrix);
                 FX_Free(intervals);
         }
 }
 
-CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
         m_pAggDriver = new CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
 }
 CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver()
 {
     delete m_pAggDriver;
 }
-FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
+bool CFX_SkiaDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* pCharPos, CFX_Font* pFont,
                 CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, FX_FIXFLOAT font_size, FX_DWORD color,
                 int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->DrawDeviceText(nChars, pCharPos, pFont,pCache, pObject2Device, font_size, color,
                 alpha_flag, pIccTransform);
 }
 int CFX_SkiaDeviceDriver::GetDeviceCaps(int caps_id)
 {
         return m_pAggDriver->GetDeviceCaps(caps_id);
 }
 void CFX_SkiaDeviceDriver::SaveState()
 {
         m_pAggDriver->SaveState();
 }
 
-void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved)
+void CFX_SkiaDeviceDriver::RestoreState(bool bKeepSaved)
 {
         m_pAggDriver->RestoreState(bKeepSaved);
 }
 void CFX_SkiaDeviceDriver::SetClipMask(rasterizer_scanline_aa& rasterizer)
 {
         m_pAggDriver->SetClipMask(rasterizer);
 }
 void CFX_SkiaDeviceDriver::SetClipMask(SkPath& skPath, SkPaint* spaint)
 {
         SkIRect clip_box;
@@ skipping 14 matching lines @@
         CFX_SkiaA8Renderer render;
         render.Init(pThisLayer, clip_box.fLeft, clip_box.fTop);
 
         SkRasterClip rasterClip(clip_box);
         SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, *spaint);
 
         // Finally, we have got the mask that we need, intersect with current clip region
         m_pAggDriver->m_pClipRgn->IntersectMaskF(clip_box.fLeft, clip_box.fTop, mask);
 
 }
-FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,   // path info
+bool CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,      // path info
                                                 const CFX_AffineMatrix* pObject2Device, // optional transformation
                                                 int fill_mode   // fill mode, WINDING or ALTERNATE
                                                 )
 {
         if (m_pAggDriver->m_pClipRgn == NULL)
                 m_pAggDriver->m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
 
         if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
                 CFX_FloatRect rectf;
                 if (pPathData->IsRect(pObject2Device, &rectf)) {
                         rectf.Intersect(CFX_FloatRect(0, 0, (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH), (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
                         FX_RECT rect = rectf.GetOutterRect();
                         m_pAggDriver->m_pClipRgn->IntersectRect(rect);
-                        return TRUE;
+                        return true;
                 }
         }
         CSkia_PathData path_data;
         path_data.BuildPath(pPathData, pObject2Device);
         path_data.m_PathData.close();
         path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING? SkPath::kWinding_FillType:SkPath::kEvenOdd_FillType);
 
         SkPaint spaint;
         spaint.setColor(0xffffffff);
-        spaint.setAntiAlias(TRUE);
+        spaint.setAntiAlias(true);
         spaint.setStyle(SkPaint::kFill_Style);
 
         SetClipMask(path_data.m_PathData, &spaint);
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData, // path info
+bool CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,    // path info
                                                 const CFX_AffineMatrix* pObject2Device, // optional transformation
                                                 const CFX_GraphStateData* pGraphState   // graphic state, for pen attributes
                                         )
 {
         if (m_pAggDriver->m_pClipRgn == NULL)
                 m_pAggDriver->m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
 
         // build path data
         CSkia_PathData path_data;
         path_data.BuildPath(pPathData, NULL);
         path_data.m_PathData.setFillType(SkPath::kWinding_FillType);
 
         SkPaint spaint;
         spaint.setColor(0xffffffff);
         spaint.setStyle(SkPaint::kStroke_Style);
-        spaint.setAntiAlias(TRUE);
+        spaint.setAntiAlias(true);
 
         SkPath dst_path;
-        SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device, pGraphState, 1, FALSE, 0);
+        SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Device, pGraphState, 1, false, 0);
         spaint.setStyle(SkPaint::kFill_Style);
         SetClipMask(dst_path, &spaint);
 
-        return TRUE;
+        return true;
 }
-FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
+bool CFX_SkiaDeviceDriver::RenderRasterizer(rasterizer_scanline_aa& rasterizer, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
                                                                                           int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->RenderRasterizer(rasterizer, color, bFullCover, bGroupKnockout,alpha_flag, pIccTransform);
 }
-FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout,
-                                                        int alpha_flag, void* pIccTransform, FX_BOOL bFill)
+bool    CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath, const SkPaint& origPaint, SkIRect& rect, FX_DWORD color, bool bFullCover, bool bGroupKnockout,
+                                                        int alpha_flag, void* pIccTransform, bool bFill)
 {
         CFX_DIBitmap* pt = bGroupKnockout?m_pAggDriver->GetBackDrop():NULL;
         CFX_SkiaRenderer render;
         if (!render.Init(m_pAggDriver->m_pBitmap, pt, m_pAggDriver->m_pClipRgn, color, bFullCover, m_pAggDriver->m_bRgbByteOrder, alpha_flag, pIccTransform))
-                return FALSE;
+                return false;
 
         SkRasterClip rasterClip(rect);
         SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render,  rasterClip, origPaint);
 
-        return TRUE;
+        return true;
 
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,   // path info
+bool    CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData,   // path info
                                                 const CFX_AffineMatrix* pObject2Device, // optional transformation
                                                 const CFX_GraphStateData* pGraphState,  // graphic state, for pen attributes
                                                 FX_DWORD fill_color,                    // fill color
                                                 FX_DWORD stroke_color,                  // stroke color
                                                 int fill_mode,                                  // fill mode, WINDING or ALTERNATE. 0 for not filled
                                                 int alpha_flag,
                                                 void* pIccTransform
                                                 )
 {
-        if (GetBuffer() == NULL) return TRUE;
+        if (GetBuffer() == NULL) return true;
         FOXIT_DEBUG1("CFX_SkiaDeviceDriver::DrawPath: entering");
         SkIRect rect;
         rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT));
         if ((fill_mode & 3) && fill_color) {
                 // We have to transform before building path data, otherwise we'll have flatting problem
                 // when we enlarge a small path (flatten before transformed)
                 // TESTDOC: Bug #5115 - DS_S1Dimpact_lr.pdf
                 // build path data
                 CSkia_PathData path_data;
                 path_data.BuildPath(pPathData, pObject2Device);
                 //path_data.m_PathData.close();
                 path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING? SkPath::kWinding_FillType:SkPath::kEvenOdd_FillType);
 
                 SkPaint spaint;
-                spaint.setAntiAlias(TRUE);
+                spaint.setAntiAlias(true);
                 spaint.setStyle(SkPaint::kFill_Style);
                 spaint.setColor(fill_color);
-                if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, fill_color, fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag, pIccTransform))
-                        return FALSE;
+                if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, fill_color, fill_mode & FXFILL_FULLCOVER, false, alpha_flag, pIccTransform))
+                        return false;
         }
 
         int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STROKE(alpha_flag) : FXARGB_A(stroke_color);
 
         if (pGraphState && stroke_alpha) {
                 // We split the matrix into two parts: first part doing the scaling, so we won't have the
                 // flatness problem, second part doing the transformation, so we don't have stroking geo problem.
                 // TESTDOC: Bug #5253 - test[1].pdf
                 CFX_AffineMatrix matrix1, matrix2;
                 if (pObject2Device) {
                         matrix1.a = FXSYS_fabs(pObject2Device->a) > FXSYS_fabs(pObject2Device->b) ?
                                         FXSYS_fabs(pObject2Device->a) : FXSYS_fabs(pObject2Device->b);
                         matrix1.d = matrix1.a;//FXSYS_fabs(pObject2Device->c) > FXSYS_fabs(pObject2Device->d) ?
                                         //pObject2Device->c : pObject2Device->d;
                         matrix2.Set(pObject2Device->a/matrix1.a, pObject2Device->b/matrix1.a,
                                         pObject2Device->c/matrix1.d, pObject2Device->d/matrix1.d,
                                         pObject2Device->e, pObject2Device->f);
                 }
                 // build path data
                 CSkia_PathData path_data;
                 path_data.BuildPath(pPathData, &matrix1);
                 path_data.m_PathData.setFillType(SkPath::kWinding_FillType);
 
                 SkPaint spaint;
                 spaint.setColor(stroke_color);
                 spaint.setStyle(SkPaint::kStroke_Style);
-                spaint.setAntiAlias(TRUE);
+                spaint.setAntiAlias(true);
                 SkPath dst_path;
-                SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, FALSE, 0);
+                SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matrix2, pGraphState, matrix1.a, false, 0);
                 spaint.setStyle(SkPaint::kFill_Style);
                 int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag)<<8 | FXGETFLAG_ALPHA_STROKE(alpha_flag);
 
-                if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color, fill_mode & FXFILL_FULLCOVER, FALSE, fill_flag, pIccTransform, FALSE))
-                        return FALSE;
+                if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color, fill_mode & FXFILL_FULLCOVER, false, fill_flag, pIccTransform, false))
+                        return false;
 
         }
 
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x, int y, FX_DWORD color,
+bool CFX_SkiaDeviceDriver::SetPixel(int x, int y, FX_DWORD color,
                                                 int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform)
+bool CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color, int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect)
+bool CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect)
 {
         return m_pAggDriver->GetClipBox(pRect);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, FX_BOOL bDEdge)
+bool    CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top, void* pIccTransform, bool bDEdge)
 {
         return m_pAggDriver->GetDIBits(pBitmap, left, top, pIccTransform, bDEdge);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
+bool    CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD argb, const FX_RECT* pSrcRect, int left, int top, int blend_type,
                                                                            int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->SetDIBits(pBitmap, argb, pSrcRect, left, top, blend_type, alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
+bool    CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWORD argb, int dest_left, int dest_top,
                                                         int dest_width, int dest_height, const FX_RECT* pClipRect, FX_DWORD flags,
                                                         int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->StretchDIBits(pSource, argb, dest_left, dest_top,
                                                         dest_width, dest_height, pClipRect, flags,
                                                         alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
+bool    CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitmap_alpha, FX_DWORD argb,
                                                 const CFX_AffineMatrix* pMatrix, FX_DWORD render_flags, void*& handle,
                                                 int alpha_flag, void* pIccTransform)
 {
         return m_pAggDriver->StartDIBits(pSource, bitmap_alpha, argb,
                                                 pMatrix, render_flags, handle, alpha_flag, pIccTransform);
 }
 
-FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
+bool    CFX_SkiaDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause)
 {
         return m_pAggDriver->ContinueDIBits(pHandle, pPause);
 }
 
 void CFX_SkiaDeviceDriver::CancelDIBits(void* pHandle)
 {
         m_pAggDriver->CancelDIBits(pHandle);
 }
 
 CFX_SkiaDevice::CFX_SkiaDevice()
 {
-        m_bOwnedBitmap = FALSE;
+        m_bOwnedBitmap = false;
 }
 
-FX_BOOL CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout)
+bool CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, bool bRgbByteOrder, CFX_DIBitmap* pOriDevice, bool bGroupKnockout)
 {
         if (pBitmap == NULL)
-                return FALSE;
+                return false;
         SetBitmap(pBitmap);
         CFX_SkiaDeviceDriver* pDriver = new CFX_SkiaDeviceDriver(pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
         SetDeviceDriver(pDriver);
-        return TRUE;
+        return true;
 }
 
-FX_BOOL CFX_SkiaDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
+bool CFX_SkiaDevice::Create(int width, int height, FXDIB_Format format, int dither_bits, CFX_DIBitmap* pOriDevice)
 {
-        m_bOwnedBitmap = TRUE;
+        m_bOwnedBitmap = true;
         CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
         if (!pBitmap->Create(width, height, format)) {
                 delete pBitmap;
-                return FALSE;
+                return false;
         }
         SetBitmap(pBitmap);
-        CFX_SkiaDeviceDriver* pDriver =  new CFX_SkiaDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
+        CFX_SkiaDeviceDriver* pDriver =  new CFX_SkiaDeviceDriver(pBitmap, dither_bits, false, pOriDevice, false);
         SetDeviceDriver(pDriver);
-        return TRUE;
+        return true;
 }
 CFX_SkiaDevice::~CFX_SkiaDevice()
 {
         if (m_bOwnedBitmap && GetBitmap()) delete GetBitmap();
 }
 
 #endif