Return unique_ptr from GetAlphaMask.

core/fxge/dib/fx_dib_convert.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 <memory>
 #include <utility>
 
 #include "core/fxcodec/fx_codec.h"
+#include "core/fxcrt/cfx_maybe_owned.h"
 #include "core/fxge/fx_dib.h"
 #include "third_party/base/ptr_util.h"
 
 class CFX_Palette {
  public:
   CFX_Palette();
   ~CFX_Palette();
 
   bool BuildPalette(const CFX_DIBSource* pBitmap);
   uint32_t* GetPalette() const { return m_pPalette; }
@@ skipping 763 matching lines @@
 
 std::unique_ptr<CFX_DIBitmap> CFX_DIBSource::CloneConvert(
     FXDIB_Format dest_format) const {
   if (dest_format == GetFormat())
     return Clone(nullptr);
 
   std::unique_ptr<CFX_DIBitmap> pClone = pdfium::MakeUnique<CFX_DIBitmap>();
   if (!pClone->Create(m_Width, m_Height, dest_format))
     return nullptr;
 
-  CFX_DIBitmap* pSrcAlpha = nullptr;
+  CFX_MaybeOwned<CFX_DIBitmap> pSrcAlpha;
   if (HasAlpha()) {
-    pSrcAlpha = (GetFormat() == FXDIB_Argb) ? GetAlphaMask() : m_pAlphaMask;
+    if (GetFormat() == FXDIB_Argb)
+      pSrcAlpha = CloneAlphaMask();
+    else
+      pSrcAlpha = m_pAlphaMask;
+
     if (!pSrcAlpha)
       return nullptr;
   }
-
   bool ret = true;
   if (dest_format & 0x0200) {
     if (dest_format == FXDIB_Argb) {
-      ret = pSrcAlpha ? pClone->LoadChannel(FXDIB_Alpha, pSrcAlpha, FXDIB_Alpha)
-                      : pClone->LoadChannel(FXDIB_Alpha, 0xff);
+      ret = pSrcAlpha
+                ? pClone->LoadChannel(FXDIB_Alpha, pSrcAlpha.Get(), FXDIB_Alpha)
+                : pClone->LoadChannel(FXDIB_Alpha, 0xff);
     } else {
-      ret = pClone->CopyAlphaMask(pSrcAlpha);
+      ret = pClone->SetAlphaMask(pSrcAlpha.Get());
     }
   }
-  if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
-    delete pSrcAlpha;
-    pSrcAlpha = nullptr;
-  }
   if (!ret)
     return nullptr;
 
   std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
   if (!ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
                      m_Width, m_Height, this, 0, 0, &pal_8bpp)) {
     return nullptr;
   }
   if (pal_8bpp)
-    pClone->CopyPalette(pal_8bpp.get());
+    pClone->SetPalette(pal_8bpp.get());
 
   return pClone;
 }
 
 bool CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format) {
   FXDIB_Format src_format = GetFormat();
   if (dest_format == src_format)
     return true;
 
   if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
@@ skipping 26 matching lines @@
         uint8_t* pDstScanline = dest_buf + row * dest_pitch + 3;
         const uint8_t* pSrcScanline = m_pAlphaMask->GetScanline(row);
         for (int col = 0; col < m_Width; col++) {
           *pDstScanline = *pSrcScanline++;
           pDstScanline += 4;
         }
       }
     }
   } else if (dest_format & 0x0200) {
     if (src_format == FXDIB_Argb) {
-      pAlphaMask = GetAlphaMask();
+      pAlphaMask = CloneAlphaMask().release();

[Tom Sepez, 2016/12/14 21:31:43]

battle for another day ...

       if (!pAlphaMask) {
         FX_Free(dest_buf);
         return false;
       }
     } else {
       if (!m_pAlphaMask) {
         if (!BuildAlphaMask()) {
           FX_Free(dest_buf);
           return false;
         }
@@ skipping 20 matching lines @@
   m_pPalette = std::move(pal_8bpp);
   if (!m_bExtBuf)
     FX_Free(m_pBuffer);
   m_bExtBuf = false;
   m_pBuffer = dest_buf;
   m_bpp = (uint8_t)dest_format;
   m_AlphaFlag = (uint8_t)(dest_format >> 8);
   m_Pitch = dest_pitch;
   return true;
 }