Use smart pointers for class owned member variables

core/fpdfapi/fpdf_render/fpdf_render_image.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 <utility>
 #include <vector>
@@ skipping 308 matching lines @@
         *dest_buf++ = m_RampB[*(src_buf++)];
         *dest_buf++ = m_RampG[*(src_buf++)];
         *dest_buf++ = m_RampR[*(src_buf++)];
         *dest_buf++ = *(src_buf++);
       }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     }
 #endif
   }
 }
+
 CPDF_ImageRenderer::CPDF_ImageRenderer() {
   m_pRenderStatus = nullptr;
   m_pImageObject = nullptr;
   m_Result = TRUE;
   m_Status = 0;
-  m_pTransformer = nullptr;
   m_DeviceHandle = nullptr;
-  m_LoadHandle = nullptr;
-  m_pClone = nullptr;
   m_bStdCS = FALSE;
   m_bPatternColor = FALSE;
   m_BlendType = FXDIB_BLEND_NORMAL;
   m_pPattern = nullptr;
   m_pObj2Device = nullptr;
 }
+
 CPDF_ImageRenderer::~CPDF_ImageRenderer() {
-  delete m_pTransformer;
   if (m_DeviceHandle) {
     m_pRenderStatus->m_pDevice->CancelDIBits(m_DeviceHandle);
   }
-  delete m_LoadHandle;
-  delete m_pClone;
 }
+
 FX_BOOL CPDF_ImageRenderer::StartLoadDIBSource() {
   CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
   FX_RECT image_rect = image_rect_f.GetOutterRect();
   int dest_width = image_rect.Width();
   int dest_height = image_rect.Height();
   if (m_ImageMatrix.a < 0) {
     dest_width = -dest_width;
   }
   if (m_ImageMatrix.d > 0) {
     dest_height = -dest_height;
   }
   if (m_Loader.Start(m_pImageObject,
-                     m_pRenderStatus->m_pContext->GetPageCache(), m_LoadHandle,
+                     m_pRenderStatus->m_pContext->GetPageCache(), &m_LoadHandle,
                      m_bStdCS, m_pRenderStatus->m_GroupFamily,
                      m_pRenderStatus->m_bLoadMask, m_pRenderStatus, dest_width,
                      dest_height)) {
     if (m_LoadHandle) {
       m_Status = 4;
       return TRUE;
     }
   }
   return FALSE;
 }
+
 FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource() {
   if (!m_Loader.m_pBitmap) {
     return FALSE;
   }
   m_BitmapAlpha = 255;
   const CPDF_GeneralStateData* pGeneralState =
       m_pImageObject->m_GeneralState.GetObject();
   if (pGeneralState) {
     m_BitmapAlpha = FXSYS_round(pGeneralState->m_FillAlpha * 255);
   }
@@ skipping 24 matching lines @@
   if (m_pDIBSource->IsAlphaMask()) {
     CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor();
     if (pColor && pColor->IsPattern()) {
       m_pPattern = pColor->GetPattern();
       if (m_pPattern) {
         m_bPatternColor = TRUE;
       }
     }
     m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject);
   } else if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_GRAY) {
-    m_pClone = m_pDIBSource->Clone();
+    m_pClone.reset(m_pDIBSource->Clone());
     m_pClone->ConvertColorScale(m_pRenderStatus->m_Options.m_BackColor,
                                 m_pRenderStatus->m_Options.m_ForeColor);
-    m_pDIBSource = m_pClone;
+    m_pDIBSource = m_pClone.get();
   }
   m_Flags = 0;
   if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_DOWNSAMPLE) {
     m_Flags |= RENDER_FORCE_DOWNSAMPLE;
   } else if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_HALFTONE) {
     m_Flags |= RENDER_FORCE_HALFTONE;
   }
   if (m_pRenderStatus->m_pDevice->GetDeviceClass() != FXDC_DISPLAY) {
     CPDF_Object* pFilters =
         m_pImageObject->m_pImage->GetStream()->GetDict()->GetDirectObjectBy(
@@ skipping 48 matching lines @@
       int format = pColorSpace->GetFamily();
       if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
           format == PDFCS_DEVICEN) {
         m_BlendType = FXDIB_BLEND_DARKEN;
       }
       pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
     }
   }
   return StartDIBSource();
 }
+
 FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
                                   const CPDF_PageObject* pObj,
                                   const CFX_Matrix* pObj2Device,
                                   FX_BOOL bStdCS,
                                   int blendType) {
   m_pRenderStatus = pStatus;
   m_bStdCS = bStdCS;
   m_pImageObject = pObj->AsImage();
   m_BlendType = blendType;
   m_pObj2Device = pObj2Device;
   CPDF_Dictionary* pOC = m_pImageObject->m_pImage->GetOC();
   if (pOC && m_pRenderStatus->m_Options.m_pOCContext &&
       !m_pRenderStatus->m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
     return FALSE;
   }
   m_ImageMatrix = m_pImageObject->m_Matrix;
   m_ImageMatrix.Concat(*pObj2Device);
   if (StartLoadDIBSource()) {
     return TRUE;
   }
   return StartRenderDIBSource();
 }
+
 FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
                                   const CFX_DIBSource* pDIBSource,
                                   FX_ARGB bitmap_argb,
                                   int bitmap_alpha,
                                   const CFX_Matrix* pImage2Device,
                                   uint32_t flags,
                                   FX_BOOL bStdCS,
                                   int blendType) {
   m_pRenderStatus = pStatus;
   m_pDIBSource = pDIBSource;
   m_FillArgb = bitmap_argb;
   m_BitmapAlpha = bitmap_alpha;
   m_ImageMatrix = *pImage2Device;
   m_Flags = flags;
   m_bStdCS = bStdCS;
   m_BlendType = blendType;
   return StartDIBSource();
 }
+
 FX_BOOL CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) {
   if (m_pRenderStatus->m_bPrint &&
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
     m_Result = FALSE;
     return FALSE;
   }
   FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
   rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
   if (rect.IsEmpty()) {
     return FALSE;
@@ skipping 225 matching lines @@
   if ((FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
       (FXSYS_fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0)) {
     if (m_pRenderStatus->m_bPrint &&
         !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
       m_Result = FALSE;
       return FALSE;
     }
     FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
     clip_box.Intersect(image_rect);
     m_Status = 2;
-    m_pTransformer = new CFX_ImageTransformer(m_pDIBSource, &m_ImageMatrix,
-                                              m_Flags, &clip_box);
+    m_pTransformer.reset(new CFX_ImageTransformer(m_pDIBSource, &m_ImageMatrix,
+                                                  m_Flags, &clip_box));
     m_pTransformer->Start();
     return TRUE;
   }
   if (m_ImageMatrix.a < 0)
     dest_width = -dest_width;
 
   if (m_ImageMatrix.d > 0)
     dest_height = -dest_height;
 
   int dest_left = dest_width > 0 ? image_rect.left : image_rect.right;
@@ skipping 101 matching lines @@
       m_Result = m_pRenderStatus->m_pDevice->SetDIBitsWithBlend(
           pBitmap.get(), m_pTransformer->result().left,
           m_pTransformer->result().top, m_BlendType);
     }
     return FALSE;
   }
   if (m_Status == 3)
     return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
 
   if (m_Status == 4) {
-    if (m_Loader.Continue(m_LoadHandle, pPause))
+    if (m_Loader.Continue(m_LoadHandle.get(), pPause))
       return TRUE;
 
     if (StartRenderDIBSource())
       return Continue(pPause);
   }
   return FALSE;
 }
 
 CCodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
@@ skipping 126 matching lines @@
   } else if (pFunc) {
     int size = dest_pitch * height;
     for (int i = 0; i < size; i++) {
       dest_buf[i] = transfers[src_buf[i]];
     }
   } else {
     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
   }
   return pMask.release();
 }