Remove default argument from RestoreState() methods.

core/fxge/apple/fx_quartz_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 "core/fxcrt/include/fx_ext.h"
 
 #ifndef _SKIA_SUPPORT_
 #include "core/fxge/agg/fx_agg_driver.h"
@@ skipping 200 matching lines @@
   }
 }
 CFX_Matrix CFX_QuartzDeviceDriver::GetCTM() const {
   CGAffineTransform ctm = CGContextGetCTM(m_context);
   return CFX_Matrix(ctm.a, ctm.b, ctm.c, ctm.d, ctm.tx, ctm.ty);
 }
 void CFX_QuartzDeviceDriver::SaveState() {
   CGContextSaveGState(m_context);
   m_saveCount++;
 }
-void CFX_QuartzDeviceDriver::RestoreState(FX_BOOL isKeepSaved) {
+
+void CFX_QuartzDeviceDriver::RestoreState(bool isKeepSaved) {
   CGContextRestoreGState(m_context);
   if (isKeepSaved) {
     CGContextSaveGState(m_context);
   } else {
     m_saveCount--;
   }
 }
+
 FX_BOOL CFX_QuartzDeviceDriver::SetClip_PathFill(const CFX_PathData* pathData,
                                                  const CFX_Matrix* matrix,
                                                  int fillMode) {
   SaveState();
   CGAffineTransform m = CGAffineTransformIdentity;
   if (matrix) {
     m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(),
                               matrix->GetD(), matrix->GetE(), matrix->GetF());
   }
   m = CGAffineTransformConcat(m, m_foxitDevice2User);
   CGContextConcatCTM(m_context, m);
   setPathToContext(pathData);
-  RestoreState(FALSE);
+  RestoreState(false);
   if ((fillMode & 3) == FXFILL_WINDING) {
     CGContextClip(m_context);
   } else {
     CGContextEOClip(m_context);
   }
   return TRUE;
 }
 FX_FLOAT CFX_QuartzDeviceDriver::getLineWidth(
     const CFX_GraphStateData* graphState,
     CGAffineTransform ctm) {
@@ skipping 18 matching lines @@
   if (matrix) {
     m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(),
                               matrix->GetD(), matrix->GetE(), matrix->GetF());
   }
   m = CGAffineTransformConcat(m, m_foxitDevice2User);
   CGContextConcatCTM(m_context, m);
   FX_FLOAT lineWidth = getLineWidth(graphState, m);
   setStrokeInfo(graphState, 0xFF000000, lineWidth);
   setPathToContext(pathData);
   CGContextReplacePathWithStrokedPath(m_context);
-  RestoreState(FALSE);
+  RestoreState(false);
   CGContextClip(m_context);
   return TRUE;
 }
 static CGBlendMode GetCGBlendMode(int blend_type) {
   CGBlendMode mode = kCGBlendModeNormal;
   switch (blend_type) {
     case FXDIB_BLEND_NORMAL:
       mode = kCGBlendModeNormal;
       break;
     case FXDIB_BLEND_MULTIPLY:
@@ skipping 91 matching lines @@
     CGContextStrokePath(m_context);
   } else if (pathMode == 1) {
     CGContextFillPath(m_context);
   } else if (pathMode == 2) {
     CGContextEOFillPath(m_context);
   } else if (pathMode == 5) {
     CGContextDrawPath(m_context, kCGPathFillStroke);
   } else if (pathMode == 6) {
     CGContextDrawPath(m_context, kCGPathEOFillStroke);
   }
-  RestoreState(FALSE);
+  RestoreState(false);
   return TRUE;
 }
 FX_BOOL CFX_QuartzDeviceDriver::FillRect(const FX_RECT* rect,
                                          FX_ARGB fillArgb,
                                          int alphaFlag,
                                          void* iccTransform,
                                          int blend_type) {
   CGBlendMode mode = GetCGBlendMode(blend_type);
   if (mode != kCGBlendModeNormal) {
     CGContextSetBlendMode(m_context, mode);
@@ skipping 143 matching lines @@
   rect_usr = CGRectOffset(rect_usr, -src_left, -src_top);
   CG_SetImageTransform(dest_left, dest_top, src_width, src_height, &rect_usr);
   CFX_DIBitmap* pBitmap1 = NULL;
   if (pBitmap->IsAlphaMask()) {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
     if (NULL == pBitmap1) {
-      RestoreState(FALSE);
+      RestoreState(false);
       return FALSE;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
         NULL, pBitmap1->GetBuffer(),
         pBitmap1->GetPitch() * pBitmap1->GetHeight(), NULL);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
         pBitmapProvider, NULL, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect_usr, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect_usr);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
     if (pBitmap1 != pBitmap) {
       delete pBitmap1;
     }
-    RestoreState(FALSE);
+    RestoreState(false);
     return TRUE;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
   }
   if (NULL == pBitmap1) {
-    RestoreState(FALSE);
+    RestoreState(false);
     return FALSE;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
-        RestoreState(FALSE);
+        RestoreState(false);
         return FALSE;
       }
     }
     for (int row = 0; row < pBitmap1->GetHeight(); row++) {
       uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
       for (int col = 0; col < pBitmap1->GetWidth(); col++) {
         pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
         pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
         pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
         pScanline += 4;
@@ skipping 13 matching lines @@
   } else if (blendType > FXDIB_BLEND_LUMINOSITY || blendType < 0) {
     blend_mode = kCGBlendModeNormal;
   }
   CGContextSetBlendMode(m_context, (CGBlendMode)blend_mode);
   CGContextDrawImage(m_context, rect_usr, image);
   CGImageRelease(image);
   CGContextRelease(ctx);
   if (pBitmap1 != pBitmap) {
     delete pBitmap1;
   }
-  RestoreState(FALSE);
+  RestoreState(false);
   return TRUE;
 }
 FX_BOOL CFX_QuartzDeviceDriver::StretchDIBits(const CFX_DIBSource* pBitmap,
                                               FX_ARGB argb,
                                               int dest_left,
                                               int dest_top,
                                               int dest_width,
                                               int dest_height,
                                               const FX_RECT* clipRect,
                                               uint32_t flags,
@@ skipping 20 matching lines @@
   }
   CG_SetImageTransform(dest_left, dest_top, dest_width, dest_height);
   CFX_DIBitmap* pBitmap1 = NULL;
   if (pBitmap->IsAlphaMask()) {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
     if (NULL == pBitmap1) {
-      RestoreState(FALSE);
+      RestoreState(false);
       return FALSE;
     }
     CGDataProviderRef pBitmapProvider = CGDataProviderCreateWithData(
         NULL, pBitmap1->GetBuffer(),
         pBitmap1->GetPitch() * pBitmap1->GetHeight(), NULL);
     CGColorSpaceRef pColorSpace = CGColorSpaceCreateDeviceGray();
     CGBitmapInfo bitmapInfo = kCGImageAlphaNone | kCGBitmapByteOrderDefault;
     CGImageRef pImage = CGImageCreate(
         pBitmap1->GetWidth(), pBitmap1->GetHeight(), pBitmap1->GetBPP(),
         pBitmap1->GetBPP(), pBitmap1->GetPitch(), pColorSpace, bitmapInfo,
         pBitmapProvider, NULL, true, kCGRenderingIntentDefault);
     CGContextClipToMask(m_context, rect, pImage);
     CGContextSetRGBFillColor(m_context, FXARGB_R(argb) / 255.f,
                              FXARGB_G(argb) / 255.f, FXARGB_B(argb) / 255.f,
                              FXARGB_A(argb) / 255.f);
     CGContextFillRect(m_context, rect);
     CGImageRelease(pImage);
     CGColorSpaceRelease(pColorSpace);
     CGDataProviderRelease(pBitmapProvider);
     if (pBitmap1 != pBitmap) {
       delete pBitmap1;
     }
-    RestoreState(FALSE);
+    RestoreState(false);
     return TRUE;
   }
   if (pBitmap->GetBPP() < 32) {
     pBitmap1 = pBitmap->CloneConvert(FXDIB_Rgb32);
   } else {
     if (pBitmap->GetBuffer()) {
       pBitmap1 = (CFX_DIBitmap*)pBitmap;
     } else {
       pBitmap1 = pBitmap->Clone();
     }
   }
   if (NULL == pBitmap1) {
-    RestoreState(FALSE);
+    RestoreState(false);
     return FALSE;
   }
   if (pBitmap1->HasAlpha()) {
     if (pBitmap1 == pBitmap) {
       pBitmap1 = pBitmap->Clone();
       if (!pBitmap1) {
-        RestoreState(FALSE);
+        RestoreState(false);
         return FALSE;
       }
     }
     for (int row = 0; row < pBitmap1->GetHeight(); row++) {
       uint8_t* pScanline = (uint8_t*)pBitmap1->GetScanline(row);
       for (int col = 0; col < pBitmap1->GetWidth(); col++) {
         pScanline[0] = (uint8_t)(pScanline[0] * pScanline[3] / 255.f + .5f);
         pScanline[1] = (uint8_t)(pScanline[1] * pScanline[3] / 255.f + .5f);
         pScanline[2] = (uint8_t)(pScanline[2] * pScanline[3] / 255.f + .5f);
         pScanline += 4;
       }
     }
   }
   CGContextRef ctx = createContextWithBitmap(pBitmap1);
   CGImageRef image = CGBitmapContextCreateImage(ctx);
   CGContextDrawImage(m_context, rect, image);
   CGImageRelease(image);
   CGContextRelease(ctx);
   if (pBitmap1 != pBitmap) {
     delete pBitmap1;
   }
-  RestoreState(FALSE);
+  RestoreState(false);
   return TRUE;
 }
 FX_BOOL CFX_QuartzDeviceDriver::CG_DrawGlypRun(int nChars,
                                                const FXTEXT_CHARPOS* pCharPos,
                                                CFX_Font* pFont,
                                                CFX_FontCache* pCache,
                                                const CFX_Matrix* pGlyphMatrix,
                                                const CFX_Matrix* pObject2Device,
                                                FX_FLOAT font_size,
                                                uint32_t argb,
@@ skipping 46 matching lines @@
         pGlyphMatrix->a, pGlyphMatrix->b, pGlyphMatrix->c, pGlyphMatrix->d,
         pGlyphMatrix->e, pGlyphMatrix->f);
     if (m_foxitDevice2User.d < 0) {
       glyph_matrix = CGAffineTransformInvert(glyph_matrix);
     }
     CGContextConcatCTM(m_context, glyph_matrix);
     CGContextTranslateCTM(m_context, -origin.x, -origin.y);
   }
   CGContextShowGlyphsAtPositions(m_context, (CGGlyph*)glyph_indices,
                                  glyph_positions, nChars);
-  RestoreState(FALSE);
+  RestoreState(false);
   return TRUE;
 }
 FX_BOOL CFX_QuartzDeviceDriver::DrawDeviceText(int nChars,
                                                const FXTEXT_CHARPOS* pCharPos,
                                                CFX_Font* pFont,
                                                CFX_FontCache* pCache,
                                                const CFX_Matrix* pObject2Device,
                                                FX_FLOAT font_size,
                                                uint32_t color,
                                                int alpha_flag,
                                                void* pIccTransform) {
   if (NULL == pFont || NULL == m_context)
     return FALSE;
   FX_BOOL bBold = pFont->IsBold();
   if (!bBold && pFont->GetSubstFont() &&
       pFont->GetSubstFont()->m_Weight >= 500 &&
       pFont->GetSubstFont()->m_Weight <= 600) {
     return FALSE;
   }
   SaveState();
   CGContextSetTextDrawingMode(m_context, kCGTextFillClip);
   FX_BOOL ret = FALSE;
   int32_t i = 0;
   while (i < nChars) {
     if (pCharPos[i].m_bGlyphAdjust || font_size < 0) {
       if (i > 0) {
         ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device,
                              font_size, color, alpha_flag, pIccTransform);
         if (!ret) {
-          RestoreState(FALSE);
+          RestoreState(false);
           return ret;
         }
       }
       const FXTEXT_CHARPOS* char_pos = pCharPos + i;
       CFX_Matrix glphy_matrix;
       if (font_size < 0) {
         glphy_matrix.Concat(-1, 0, 0, -1, 0, 0);
       }
       if (char_pos->m_bGlyphAdjust) {
         glphy_matrix.Concat(
             char_pos->m_AdjustMatrix[0], char_pos->m_AdjustMatrix[1],
             char_pos->m_AdjustMatrix[2], char_pos->m_AdjustMatrix[3], 0, 0);
       }
       ret = CG_DrawGlypRun(1, char_pos, pFont, pCache, &glphy_matrix,
                            pObject2Device, font_size, color, alpha_flag,
                            pIccTransform);
       if (!ret) {
-        RestoreState(FALSE);
+        RestoreState(false);
         return ret;
       }
       i++;
       pCharPos += i;
       nChars -= i;
       i = 0;
     } else {
       i++;
     }
   }
   if (i > 0) {
     ret = CG_DrawGlypRun(i, pCharPos, pFont, pCache, NULL, pObject2Device,
                          font_size, color, alpha_flag, pIccTransform);
   }
-  RestoreState(FALSE);
+  RestoreState(false);
   return ret;
 }
 void CFX_QuartzDeviceDriver::setStrokeInfo(const CFX_GraphStateData* graphState,
                                            FX_ARGB argb,
                                            FX_FLOAT lineWidth) {
   if (NULL == graphState) {
     return;
   }
   CGContextSetLineWidth(m_context, lineWidth);
   CGLineCap cap;
@@ skipping 163 matching lines @@
   }
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   if (!pBitmap->Create(width, height, format)) {
     delete pBitmap;
     return FALSE;
   }
   m_bOwnedBitmap = TRUE;
   return Attach(pBitmap);
 }
 #endif  // _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_