Return unique_ptr from CFX_BinaryBuf::DetachBuffer()

core/fpdfapi/page/cpdf_image.cpp

 // Copyright 2016 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/page/cpdf_image.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 201 matching lines @@
     }
     pDict->SetNewFor<CPDF_Number>("BitsPerComponent", 1);
     dest_pitch = (BitmapWidth + 7) / 8;
   } else if (bpp == 8) {
     int32_t iPalette = pBitmap->GetPaletteSize();
     if (iPalette > 0) {
       CPDF_Array* pCS = m_pDocument->NewIndirect<CPDF_Array>();
       pCS->AddNew<CPDF_Name>("Indexed");
       pCS->AddNew<CPDF_Name>("DeviceRGB");
       pCS->AddNew<CPDF_Number>(iPalette - 1);
-      uint8_t* pColorTable = FX_Alloc2D(uint8_t, iPalette, 3);
-      uint8_t* ptr = pColorTable;
+      std::unique_ptr<uint8_t, FxFreeDeleter> pColorTable(
+          FX_Alloc2D(uint8_t, iPalette, 3));
+      uint8_t* ptr = pColorTable.get();
       for (int32_t i = 0; i < iPalette; i++) {
         uint32_t argb = pBitmap->GetPaletteArgb(i);
         ptr[0] = (uint8_t)(argb >> 16);
         ptr[1] = (uint8_t)(argb >> 8);
         ptr[2] = (uint8_t)argb;
         ptr += 3;
       }
       auto pNewDict =
           pdfium::MakeUnique<CPDF_Dictionary>(m_pDocument->GetByteStringPool());
       CPDF_Stream* pCTS = m_pDocument->NewIndirect<CPDF_Stream>(
-          pColorTable, iPalette * 3, std::move(pNewDict));
+          std::move(pColorTable), iPalette * 3, std::move(pNewDict));
       pCS->AddNew<CPDF_Reference>(m_pDocument, pCTS->GetObjNum());
       pDict->SetNewFor<CPDF_Reference>("ColorSpace", m_pDocument,
                                        pCS->GetObjNum());
     } else {
       pDict->SetNewFor<CPDF_Name>("ColorSpace", "DeviceGray");
     }
     pDict->SetNewFor<CPDF_Number>("BitsPerComponent", 8);
     dest_pitch = BitmapWidth;
   } else {
     pDict->SetNewFor<CPDF_Name>("ColorSpace", "DeviceRGB");
     pDict->SetNewFor<CPDF_Number>("BitsPerComponent", 8);
     dest_pitch = BitmapWidth * 3;
     bCopyWithoutAlpha = false;
   }
 
   std::unique_ptr<CFX_DIBitmap> pMaskBitmap;
   if (pBitmap->HasAlpha())
     pMaskBitmap = pBitmap->CloneAlphaMask();
 
   if (pMaskBitmap) {
     int32_t maskWidth = pMaskBitmap->GetWidth();
     int32_t maskHeight = pMaskBitmap->GetHeight();
-    uint8_t* mask_buf = nullptr;
+    std::unique_ptr<uint8_t, FxFreeDeleter> mask_buf;
     FX_STRSIZE mask_size = 0;
     auto pMaskDict =
         pdfium::MakeUnique<CPDF_Dictionary>(m_pDocument->GetByteStringPool());
     pMaskDict->SetNewFor<CPDF_Name>("Type", "XObject");
     pMaskDict->SetNewFor<CPDF_Name>("Subtype", "Image");
     pMaskDict->SetNewFor<CPDF_Number>("Width", maskWidth);
     pMaskDict->SetNewFor<CPDF_Number>("Height", maskHeight);
     pMaskDict->SetNewFor<CPDF_Name>("ColorSpace", "DeviceGray");
     pMaskDict->SetNewFor<CPDF_Number>("BitsPerComponent", 8);
     if (pMaskBitmap->GetFormat() != FXDIB_1bppMask) {
-      mask_buf = FX_Alloc2D(uint8_t, maskHeight, maskWidth);
+      mask_buf.reset(FX_Alloc2D(uint8_t, maskHeight, maskWidth));
       mask_size = maskHeight * maskWidth;  // Safe since checked alloc returned.
       for (int32_t a = 0; a < maskHeight; a++) {
-        FXSYS_memcpy(mask_buf + a * maskWidth, pMaskBitmap->GetScanline(a),
-                     maskWidth);
+        FXSYS_memcpy(mask_buf.get() + a * maskWidth,
+                     pMaskBitmap->GetScanline(a), maskWidth);
       }
     }
     pMaskDict->SetNewFor<CPDF_Number>("Length", mask_size);
     CPDF_Stream* pNewStream = m_pDocument->NewIndirect<CPDF_Stream>(
-        mask_buf, mask_size, std::move(pMaskDict));
+        std::move(mask_buf), mask_size, std::move(pMaskDict));
     pDict->SetNewFor<CPDF_Reference>("SMask", m_pDocument,
                                      pNewStream->GetObjNum());
   }
 
   uint8_t* src_buf = pBitmap->GetBuffer();
   int32_t src_pitch = pBitmap->GetPitch();
   uint8_t* dest_buf = FX_Alloc2D(uint8_t, dest_pitch, BitmapHeight);
   // Safe as checked alloc returned.
   FX_STRSIZE dest_size = dest_pitch * BitmapHeight;
   uint8_t* pDest = dest_buf;
@@ skipping 92 matching lines @@
   }
   if (!ret) {
     delete m_pDIBSource;
     m_pDIBSource = nullptr;
     return false;
   }
   m_pMask = pSource->DetachMask();
   m_MatteColor = pSource->GetMatteColor();
   return false;
 }