Return unique_ptrs from CFX_DIBitmap::Clone().

core/fxge/win32/fx_win32_gdipext.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 <windows.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "core/fxcrt/fx_system.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "core/fxge/cfx_graphstatedata.h"
 #include "core/fxge/cfx_pathdata.h"
 #include "core/fxge/win32/cfx_windowsdib.h"
 #include "core/fxge/win32/win32_int.h"
+#include "third_party/base/ptr_util.h"
 
 // Has to come before gdiplus.h
 namespace Gdiplus {
 using std::min;
 using std::max;
 }  // namespace Gdiplus
 
 #include <gdiplus.h>  // NOLINT
 
 using namespace Gdiplus;              // NOLINT
@@ skipping 424 matching lines @@
          m_pGdiRemoveFontMemResourseEx((HANDLE)handle);
 }
 
 static GpBrush* _GdipCreateBrush(DWORD argb) {
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   GpSolidFill* solidBrush = nullptr;
   CallFunc(GdipCreateSolidFill)((ARGB)argb, &solidBrush);
   return solidBrush;
 }
-static CFX_DIBitmap* _StretchMonoToGray(int dest_width,
-                                        int dest_height,
-                                        const CFX_DIBitmap* pSource,
-                                        FX_RECT* pClipRect) {
+
+static std::unique_ptr<CFX_DIBitmap> StretchMonoToGray(
+    int dest_width,
+    int dest_height,
+    const CFX_DIBitmap* pSource,
+    FX_RECT* pClipRect) {
   bool bFlipX = dest_width < 0;
-  if (bFlipX) {
+  if (bFlipX)
     dest_width = -dest_width;
-  }
+
   bool bFlipY = dest_height < 0;
-  if (bFlipY) {
+  if (bFlipY)
     dest_height = -dest_height;
-  }
+
   int result_width = pClipRect->Width();
   int result_height = pClipRect->Height();
   int result_pitch = (result_width + 3) / 4 * 4;
-  CFX_DIBitmap* pStretched = new CFX_DIBitmap;
-  if (!pStretched->Create(result_width, result_height, FXDIB_8bppRgb)) {
-    delete pStretched;
+  auto pStretched = pdfium::MakeUnique<CFX_DIBitmap>();
+  if (!pStretched->Create(result_width, result_height, FXDIB_8bppRgb))
     return nullptr;
-  }
+
   LPBYTE dest_buf = pStretched->GetBuffer();
   int src_width = pSource->GetWidth();
   int src_height = pSource->GetHeight();
   int y_unit = src_height / dest_height;
   int x_unit = src_width / dest_width;
   int area_unit = y_unit * x_unit;
   LPBYTE src_buf = pSource->GetBuffer();
   int src_pitch = pSource->GetPitch();
   for (int dest_y = 0; dest_y < result_height; dest_y++) {
     LPBYTE dest_scan = dest_buf + dest_y * result_pitch;
@@ skipping 14 matching lines @@
             sum += 255;
           }
         }
         src_line += src_pitch;
       }
       dest_scan[dest_x] = 255 - sum / area_unit;
     }
   }
   return pStretched;
 }
+
 static void OutputImageMask(GpGraphics* pGraphics,
                             BOOL bMonoDevice,
                             const CFX_DIBitmap* pBitmap,
                             int dest_left,
                             int dest_top,
                             int dest_width,
                             int dest_height,
                             FX_ARGB argb,
                             const FX_RECT* pClipRect) {
   ASSERT(pBitmap->GetBPP() == 1);
@@ skipping 26 matching lines @@
       abs(dest_height) < src_height) {
     FX_RECT image_rect(dest_left, dest_top, dest_left + dest_width,
                        dest_top + dest_height);
     image_rect.Normalize();
     FX_RECT image_clip = image_rect;
     image_clip.Intersect(*pClipRect);
     if (image_clip.IsEmpty()) {
       return;
     }
     image_clip.Offset(-image_rect.left, -image_rect.top);
-    CFX_DIBitmap* pStretched = nullptr;
+    std::unique_ptr<CFX_DIBitmap> pStretched;
     if (src_width * src_height > 10000) {
       pStretched =
-          _StretchMonoToGray(dest_width, dest_height, pBitmap, &image_clip);
+          StretchMonoToGray(dest_width, dest_height, pBitmap, &image_clip);
     } else {
       pStretched =
           pBitmap->StretchTo(dest_width, dest_height, false, &image_clip);
     }
     GpBitmap* bitmap;
     CallFunc(GdipCreateBitmapFromScan0)(image_clip.Width(), image_clip.Height(),
                                         (image_clip.Width() + 3) / 4 * 4,
                                         PixelFormat8bppIndexed,
                                         pStretched->GetBuffer(), &bitmap);
     int a, r, g, b;
     ArgbDecode(argb, a, r, g, b);
     UINT pal[258];
     pal[0] = 0;
     pal[1] = 256;
     for (int i = 0; i < 256; i++) {
       pal[i + 2] = ArgbEncode(i * a / 255, r, g, b);
     }
     CallFunc(GdipSetImagePalette)(bitmap, (ColorPalette*)pal);
     CallFunc(GdipDrawImageI)(pGraphics, bitmap,
                              image_rect.left + image_clip.left,
                              image_rect.top + image_clip.top);
     CallFunc(GdipDisposeImage)(bitmap);
-    delete pStretched;
     return;
   }
   GpBitmap* bitmap;
   CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                       PixelFormat1bppIndexed, scan0, &bitmap);
   UINT palette[4] = {PaletteFlagsHasAlpha, 2, 0, argb};
   CallFunc(GdipSetImagePalette)(bitmap, (ColorPalette*)palette);
   Point destinationPoints[] = {Point(dest_left, dest_top),
                                Point(dest_left + dest_width, dest_top),
                                Point(dest_left, dest_top + dest_height)};
   CallFunc(GdipDrawImagePointsI)(pGraphics, bitmap, destinationPoints, 3);
   CallFunc(GdipDisposeImage)(bitmap);
 }
 static void OutputImage(GpGraphics* pGraphics,
                         const CFX_DIBitmap* pBitmap,
                         const FX_RECT* pSrcRect,
                         int dest_left,
                         int dest_top,
                         int dest_width,
                         int dest_height) {
   int src_width = pSrcRect->Width(), src_height = pSrcRect->Height();
   CGdiplusExt& GdiplusExt =
       ((CWin32Platform*)CFX_GEModule::Get()->GetPlatformData())->m_GdiplusExt;
   if (pBitmap->GetBPP() == 1 && (pSrcRect->left % 8)) {
     FX_RECT new_rect(0, 0, src_width, src_height);
-    CFX_DIBitmap* pCloned = pBitmap->Clone(pSrcRect);
-    if (!pCloned) {
+    std::unique_ptr<CFX_DIBitmap> pCloned = pBitmap->Clone(pSrcRect);
+    if (!pCloned)
       return;
-    }
-    OutputImage(pGraphics, pCloned, &new_rect, dest_left, dest_top, dest_width,
-                dest_height);
-    delete pCloned;
+    OutputImage(pGraphics, pCloned.get(), &new_rect, dest_left, dest_top,
+                dest_width, dest_height);
     return;
   }
   int src_pitch = pBitmap->GetPitch();
   uint8_t* scan0 = pBitmap->GetBuffer() + pSrcRect->top * src_pitch +
                    pBitmap->GetBPP() * pSrcRect->left / 8;
   GpBitmap* bitmap = nullptr;
   switch (pBitmap->GetFormat()) {
     case FXDIB_Argb:
       CallFunc(GdipCreateBitmapFromScan0)(src_width, src_height, src_pitch,
                                           PixelFormat32bppARGB, scan0, &bitmap);
@@ skipping 884 matching lines @@
       FXSYS_memcpy(pData + dest_pitch * i, pInfo->pScan0 + pInfo->Stride * i,
                    dest_pitch);
     }
   }
   CFX_DIBitmap* pDIBitmap = _FX_WindowsDIB_LoadFromBuf(
       pInfo->pbmi, pData, pInfo->pbmi->bmiHeader.biBitCount == 32);
   FX_Free(pData);
   FreeDIBitmap(pInfo);
   return pDIBitmap;
 }