Use smart pointers for graphics device classes

core/fxge/agg/fx_agg_driver.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/fxge/agg/fx_agg_driver.h"
 
 #include <algorithm>
 
@@ skipping 402 matching lines @@
     stroke.line_cap(cap);
     stroke.miter_limit(pGraphState->m_MiterLimit);
     stroke.width(width);
     rasterizer.add_path_transformed(stroke, pObject2Device);
   }
 }
 
 CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap,
                                          FX_BOOL bRgbByteOrder,
                                          CFX_DIBitmap* pOriDevice,
-                                         FX_BOOL bGroupKnockout) {
-  m_pBitmap = pBitmap;
-  m_pClipRgn = nullptr;
-  m_pPlatformBitmap = nullptr;
-  m_pPlatformGraphics = nullptr;
-  m_pDwRenderTartget = nullptr;
-  m_bRgbByteOrder = bRgbByteOrder;
-  m_pOriDevice = pOriDevice;
-  m_bGroupKnockout = bGroupKnockout;
-  m_FillFlags = 0;
+                                         FX_BOOL bGroupKnockout)
+    : m_pBitmap(pBitmap),
+#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
+      m_pPlatformGraphics(nullptr),
+#endif
+      m_FillFlags(0),
+      m_bRgbByteOrder(bRgbByteOrder),
+      m_pOriDevice(pOriDevice),
+      m_bGroupKnockout(bGroupKnockout) {
   InitPlatform();
 }
 
 CFX_AggDeviceDriver::~CFX_AggDeviceDriver() {
-  delete m_pClipRgn;
-  for (int i = 0; i < m_StateStack.GetSize(); i++)
-    delete m_StateStack[i];
   DestroyPlatform();
 }
 
 uint8_t* CFX_AggDeviceDriver::GetBuffer() const {
   return m_pBitmap->GetBuffer();
 }
 
 const CFX_DIBitmap* CFX_AggDeviceDriver::GetBitmap() const {
   return m_pBitmap;
 }
@@ skipping 42 matching lines @@
       if (m_pBitmap->IsCmykImage()) {
         flags |= FXRC_CMYK_OUTPUT;
       }
       return flags;
     }
   }
   return 0;
 }
 
 void CFX_AggDeviceDriver::SaveState() {
-  CFX_ClipRgn* pClip = nullptr;
-  if (m_pClipRgn) {
-    pClip = new CFX_ClipRgn(*m_pClipRgn);
-  }
-  m_StateStack.Add(pClip);
+  std::unique_ptr<CFX_ClipRgn> pClip;
+  if (m_pClipRgn)
+    pClip.reset(new CFX_ClipRgn(*m_pClipRgn));
+  m_StateStack.push_back(std::move(pClip));
 }
 
 void CFX_AggDeviceDriver::RestoreState(bool bKeepSaved) {
-  delete m_pClipRgn;
-  m_pClipRgn = nullptr;
+  m_pClipRgn.reset();
 
-  int size = m_StateStack.GetSize();
-  if (!size)
+  if (m_StateStack.empty())
     return;
 
-  CFX_ClipRgn* pSavedClip = m_StateStack[size - 1];
   if (bKeepSaved) {
-    if (pSavedClip) {
-      m_pClipRgn = new CFX_ClipRgn(*pSavedClip);
-    }
+    if (m_StateStack.back())
+      m_pClipRgn.reset(new CFX_ClipRgn(*m_StateStack.back()));
   } else {
-    m_StateStack.RemoveAt(size - 1);
-    m_pClipRgn = pSavedClip;
+    m_pClipRgn = std::move(m_StateStack.back());
+    m_StateStack.pop_back();
   }
 }
 
 void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer) {
   FX_RECT path_rect(rasterizer.min_x(), rasterizer.min_y(),
                     rasterizer.max_x() + 1, rasterizer.max_y() + 1);
   path_rect.Intersect(m_pClipRgn->GetBox());
   CFX_DIBitmapRef mask;
   CFX_DIBitmap* pThisLayer = mask.New();
   if (!pThisLayer) {
@@ skipping 13 matching lines @@
   agg::render_scanlines(rasterizer, scanline, final_render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask);
 }
 
 FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
                                               const CFX_Matrix* pObject2Device,
                                               int fill_mode) {
   m_FillFlags = fill_mode;
   if (!m_pClipRgn) {
-    m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH),
-                                 GetDeviceCaps(FXDC_PIXEL_HEIGHT));
+    m_pClipRgn.reset(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_FLOAT)GetDeviceCaps(FXDC_PIXEL_WIDTH),
                         (FX_FLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
       FX_RECT rect = rectf.GetOutterRect();
       m_pClipRgn->IntersectRect(rect);
       return TRUE;
@@ skipping 11 matching lines @@
                               : agg::fill_even_odd);
   SetClipMask(rasterizer);
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,
     const CFX_Matrix* pObject2Device,
     const CFX_GraphStateData* pGraphState) {
   if (!m_pClipRgn) {
-    m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH),
-                                 GetDeviceCaps(FXDC_PIXEL_HEIGHT));
+    m_pClipRgn.reset(new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH),
+                                     GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   }
   CAgg_PathData path_data;
   path_data.BuildPath(pPathData, nullptr);
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device,
                   pGraphState);
   rasterizer.filling_rule(agg::fill_non_zero);
   SetClipMask(rasterizer);
@@ skipping 834 matching lines @@
 
 FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(
     agg::rasterizer_scanline_aa& rasterizer,
     uint32_t color,
     FX_BOOL bFullCover,
     FX_BOOL bGroupKnockout,
     int alpha_flag,
     void* pIccTransform) {
   CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : nullptr;
   CFX_Renderer render;
-  if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover,
+  if (!render.Init(m_pBitmap, pt, m_pClipRgn.get(), color, bFullCover,
                    m_bRgbByteOrder, alpha_flag, pIccTransform)) {
     return FALSE;
   }
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
@@ skipping 194 matching lines @@
 FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                        uint32_t argb,
                                        const FX_RECT* pSrcRect,
                                        int left,
                                        int top,
                                        int blend_type) {
   if (!m_pBitmap->GetBuffer())
     return TRUE;
 
   if (pBitmap->IsAlphaMask()) {
-    return m_pBitmap->CompositeMask(left, top, pSrcRect->Width(),
-                                    pSrcRect->Height(), pBitmap, argb,
-                                    pSrcRect->left, pSrcRect->top, blend_type,
-                                    m_pClipRgn, m_bRgbByteOrder, 0, nullptr);
+    return m_pBitmap->CompositeMask(
+        left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
+        pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn.get(),
+        m_bRgbByteOrder, 0, nullptr);
   }
   return m_pBitmap->CompositeBitmap(
       left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
-      pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, nullptr);
+      pSrcRect->top, blend_type, m_pClipRgn.get(), m_bRgbByteOrder, nullptr);
 }
 
 FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                            uint32_t argb,
                                            int dest_left,
                                            int dest_top,
                                            int dest_width,
                                            int dest_height,
                                            const FX_RECT* pClipRect,
                                            uint32_t flags,
                                            int blend_type) {
   if (!m_pBitmap->GetBuffer())
     return TRUE;
 
   if (dest_width == pSource->GetWidth() &&
       dest_height == pSource->GetHeight()) {
     FX_RECT rect(0, 0, dest_width, dest_height);
     return SetDIBits(pSource, argb, &rect, dest_left, dest_top, blend_type);
   }
   FX_RECT dest_rect(dest_left, dest_top, dest_left + dest_width,
                     dest_top + dest_height);
   dest_rect.Normalize();
   FX_RECT dest_clip = dest_rect;
   dest_clip.Intersect(*pClipRect);
   CFX_BitmapComposer composer;
-  composer.Compose(m_pBitmap, m_pClipRgn, 255, argb, dest_clip, FALSE, FALSE,
-                   FALSE, m_bRgbByteOrder, 0, nullptr, blend_type);
+  composer.Compose(m_pBitmap, m_pClipRgn.get(), 255, argb, dest_clip, FALSE,
+                   FALSE, FALSE, m_bRgbByteOrder, 0, nullptr, blend_type);
   dest_clip.Offset(-dest_rect.left, -dest_rect.top);
   CFX_ImageStretcher stretcher(&composer, pSource, dest_width, dest_height,
                                dest_clip, flags);
   if (stretcher.Start())
     stretcher.Continue(nullptr);
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                          int bitmap_alpha,
                                          uint32_t argb,
                                          const CFX_Matrix* pMatrix,
                                          uint32_t render_flags,
                                          void*& handle,
                                          int blend_type) {
   if (!m_pBitmap->GetBuffer())
     return TRUE;
 
   CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
-  pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix,
-                   render_flags, m_bRgbByteOrder, 0, nullptr);
+  pRenderer->Start(m_pBitmap, m_pClipRgn.get(), pSource, bitmap_alpha, argb,
+                   pMatrix, render_flags, m_bRgbByteOrder, 0, nullptr);
   handle = pRenderer;
   return TRUE;
 }
 
 FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
 }
@@ skipping 40 matching lines @@
   SetDeviceDriver(pDriver);
   return true;
 }
 
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }
 #endif