Remove default argument from RestoreState() methods.

core/fpdfapi/fpdf_render/fpdf_render.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/fpdfapi/fpdf_render/render_int.h"
 
 #include "core/fpdfapi/fpdf_font/cpdf_type3char.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3font.h"
@@ skipping 425 matching lines @@
     pResources = pFormObj->m_pForm->m_pFormDict->GetDictBy("Resources");
   }
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, m_pDevice, NULL, m_pStopObj, this, pFormObj,
                     &m_Options, m_Transparency, m_bDropObjects, pResources,
                     FALSE);
   status.m_curBlend = m_curBlend;
   m_pDevice->SaveState();
   status.RenderObjectList(pFormObj->m_pForm, &matrix);
   m_bStopped = status.m_bStopped;
-  m_pDevice->RestoreState();
+  m_pDevice->RestoreState(false);
   return TRUE;
 }
 FX_BOOL IsAvailableMatrix(const CFX_Matrix& matrix) {
   if (matrix.a == 0 || matrix.d == 0) {
     return matrix.b != 0 && matrix.c != 0;
   }
   if (matrix.b == 0 || matrix.c == 0) {
     return matrix.a != 0 && matrix.d != 0;
   }
   return TRUE;
@@ skipping 119 matching lines @@
     }
   } else {
     alpha = 255;
   }
   return m_Options.TranslateColor(ArgbEncode(alpha, rgb));
 }
 void CPDF_RenderStatus::ProcessClipPath(CPDF_ClipPath ClipPath,
                                         const CFX_Matrix* pObj2Device) {
   if (ClipPath.IsNull()) {
     if (!m_LastClipPath.IsNull()) {
-      m_pDevice->RestoreState(TRUE);
+      m_pDevice->RestoreState(true);
       m_LastClipPath.SetNull();
     }
     return;
   }
   if (m_LastClipPath == ClipPath)
     return;
 
   m_LastClipPath = ClipPath;
-  m_pDevice->RestoreState(TRUE);
+  m_pDevice->RestoreState(true);
   int nClipPath = ClipPath.GetPathCount();
   for (int i = 0; i < nClipPath; ++i) {
     const CFX_PathData* pPathData = ClipPath.GetPath(i);
     if (!pPathData)
       continue;
 
     if (pPathData->GetPointCount() == 0) {
       CFX_PathData EmptyPath;
       EmptyPath.AppendRect(-1, -1, 0, 0);
       int fill_mode = FXFILL_WINDING;
@@ skipping 361 matching lines @@
       FinalMatrix.Concat(*pLastMatrix);
       CPDF_RenderStatus status;
       status.Initialize(this, pDevice, pLastMatrix, pStopObj, NULL, NULL,
                         pOptions, pLayer->m_pObjectHolder->m_Transparency,
                         FALSE, NULL);
       status.RenderObjectList(pLayer->m_pObjectHolder, &FinalMatrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
-        pDevice->RestoreState();
+        pDevice->RestoreState(false);
         break;
       }
     } else {
       CPDF_RenderStatus status;
       status.Initialize(this, pDevice, NULL, pStopObj, NULL, NULL, pOptions,
                         pLayer->m_pObjectHolder->m_Transparency, FALSE, NULL);
       status.RenderObjectList(pLayer->m_pObjectHolder, &pLayer->m_Matrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
-        pDevice->RestoreState();
+        pDevice->RestoreState(false);
         break;
       }
     }
-    pDevice->RestoreState();
+    pDevice->RestoreState(false);
   }
 }
 
 CPDF_ProgressiveRenderer::CPDF_ProgressiveRenderer(
     CPDF_RenderContext* pContext,
     CFX_RenderDevice* pDevice,
     const CPDF_RenderOptions* pOptions)
     : m_Status(Ready),
       m_pContext(pContext),
       m_pDevice(pDevice),
       m_pOptions(pOptions),
       m_LayerIndex(0),
       m_pCurrentLayer(nullptr) {}
 
 CPDF_ProgressiveRenderer::~CPDF_ProgressiveRenderer() {
   if (m_pRenderStatus)
-    m_pDevice->RestoreState();
+    m_pDevice->RestoreState(false);
 }
 
 void CPDF_ProgressiveRenderer::Start(IFX_Pause* pPause) {
   if (!m_pContext || !m_pDevice || m_Status != Ready) {
     m_Status = Failed;
     return;
   }
   m_Status = ToBeContinued;
   Continue(pPause);
 }
@@ skipping 52 matching lines @@
       m_LastObjectRendered = iter;
       if (nObjsToGo == 0) {
         if (pPause && pPause->NeedToPauseNow())
           return;
         nObjsToGo = kStepLimit;
       }
       ++iter;
     }
     if (m_pCurrentLayer->m_pObjectHolder->IsParsed()) {
       m_pRenderStatus.reset();
-      m_pDevice->RestoreState();
+      m_pDevice->RestoreState(false);
       m_pCurrentLayer = nullptr;
       m_LayerIndex++;
       if (pPause && pPause->NeedToPauseNow()) {
         return;
       }
     } else {
       m_pCurrentLayer->m_pObjectHolder->ContinueParse(pPause);
       if (!m_pCurrentLayer->m_pObjectHolder->IsParsed())
         return;
     }
@@ skipping 194 matching lines @@
   m_pContext->GetBackground(m_pBitmapDevice->GetBitmap(), m_pObject, pOptions,
                             &m_Matrix);
   return TRUE;
 }
 void CPDF_ScaledRenderBuffer::OutputToDevice() {
   if (m_pBitmapDevice) {
     m_pDevice->StretchDIBits(m_pBitmapDevice->GetBitmap(), m_Rect.left,
                              m_Rect.top, m_Rect.Width(), m_Rect.Height());
   }
 }