Return unique_ptr from GetAlphaMask.

core/fxge/dib/fx_dib_main.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/fx_dib.h"
 
 #include <limits.h>
 
@@ skipping 110 matching lines @@
         m_pBuffer = nullptr;
         m_Width = m_Height = m_Pitch = 0;
         return false;
       }
     }
   }
   return true;
 }
 
 bool CFX_DIBitmap::Copy(const CFX_DIBSource* pSrc) {
-  if (m_pBuffer) {
+  if (m_pBuffer)
     return false;
-  }
-  if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat())) {
+
+  if (!Create(pSrc->GetWidth(), pSrc->GetHeight(), pSrc->GetFormat()))
     return false;
-  }
-  CopyPalette(pSrc->GetPalette());
-  CopyAlphaMask(pSrc->m_pAlphaMask);
-  for (int row = 0; row < pSrc->GetHeight(); row++) {
+
+  SetPalette(pSrc->GetPalette());
+  SetAlphaMask(pSrc->m_pAlphaMask);
+  for (int row = 0; row < pSrc->GetHeight(); row++)
     FXSYS_memcpy(m_pBuffer + row * m_Pitch, pSrc->GetScanline(row), m_Pitch);
-  }
+
   return true;
 }
 
 CFX_DIBitmap::~CFX_DIBitmap() {
   if (!m_bExtBuf)
     FX_Free(m_pBuffer);
 
   m_pBuffer = nullptr;
 }
 
@@ skipping 27 matching lines @@
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pClip) {
     rect.Intersect(*pClip);
     if (rect.IsEmpty())
       return nullptr;
   }
   auto pNewBitmap = pdfium::MakeUnique<CFX_DIBitmap>();
   if (!pNewBitmap->Create(rect.Width(), rect.Height(), GetFormat()))
     return nullptr;
 
-  pNewBitmap->CopyPalette(m_pPalette.get());
-  pNewBitmap->CopyAlphaMask(m_pAlphaMask, pClip);
+  pNewBitmap->SetPalette(m_pPalette.get());
+  pNewBitmap->SetAlphaMask(m_pAlphaMask, pClip);
   if (GetBPP() == 1 && rect.left % 8 != 0) {
     int left_shift = rect.left % 32;
     int right_shift = 32 - left_shift;
     int dword_count = pNewBitmap->m_Pitch / 4;
     for (int row = rect.top; row < rect.bottom; row++) {
       uint32_t* src_scan = (uint32_t*)GetScanline(row) + rect.left / 32;
       uint32_t* dest_scan = (uint32_t*)pNewBitmap->GetScanline(row - rect.top);
       for (int i = 0; i < dword_count; i++) {
         dest_scan[i] =
             (src_scan[i] << left_shift) | (src_scan[i + 1] >> right_shift);
@@ skipping 364 matching lines @@
           FXSYS_memcpy(dest_color_pos, color_p, comps);
           dest_color_pos += comps;
           *dest_alpha_pos++ = (alpha * (*src_scan++) / 255);
         }
       }
     }
   }
   return true;
 }
 
-void CFX_DIBSource::CopyPalette(const uint32_t* pSrc) {
+void CFX_DIBSource::SetPalette(const uint32_t* pSrc) {
   static const uint32_t kPaletteSize = 256;
-
   if (!pSrc || GetBPP() > 8) {
     m_pPalette.reset();
-  } else {
-    uint32_t pal_size = 1 << GetBPP();
-    if (!m_pPalette)
-      m_pPalette.reset(FX_Alloc(uint32_t, pal_size));
-    pal_size = std::min(pal_size, kPaletteSize);
-    FXSYS_memcpy(m_pPalette.get(), pSrc, pal_size * sizeof(uint32_t));
+    return;
   }
+  uint32_t pal_size = 1 << GetBPP();
+  if (!m_pPalette)
+    m_pPalette.reset(FX_Alloc(uint32_t, pal_size));
+  pal_size = std::min(pal_size, kPaletteSize);
+  FXSYS_memcpy(m_pPalette.get(), pSrc, pal_size * sizeof(uint32_t));
 }
 
 void CFX_DIBSource::GetPalette(uint32_t* pal, int alpha) const {
   ASSERT(GetBPP() <= 8 && !IsCmykImage());
   if (GetBPP() == 1) {
     pal[0] = ((m_pPalette ? m_pPalette.get()[0] : 0xff000000) & 0xffffff) |
              (alpha << 24);
     pal[1] = ((m_pPalette ? m_pPalette.get()[1] : 0xffffffff) & 0xffffff) |
              (alpha << 24);
     return;
   }
   if (m_pPalette) {
     for (int i = 0; i < 256; i++) {
       pal[i] = (m_pPalette.get()[i] & 0x00ffffff) | (alpha << 24);
     }
   } else {
     for (int i = 0; i < 256; i++) {
       pal[i] = (i * 0x10101) | (alpha << 24);
     }
   }
 }
 
-CFX_DIBitmap* CFX_DIBSource::GetAlphaMask(const FX_RECT* pClip) const {
+std::unique_ptr<CFX_DIBitmap> CFX_DIBSource::CloneAlphaMask(
+    const FX_RECT* pClip) const {
   ASSERT(GetFormat() == FXDIB_Argb);
   FX_RECT rect(0, 0, m_Width, m_Height);
   if (pClip) {
     rect.Intersect(*pClip);
-    if (rect.IsEmpty()) {
+    if (rect.IsEmpty())
       return nullptr;
-    }
   }
-  CFX_DIBitmap* pMask = new CFX_DIBitmap;
-  if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask)) {
-    delete pMask;
+  auto pMask = pdfium::MakeUnique<CFX_DIBitmap>();
+  if (!pMask->Create(rect.Width(), rect.Height(), FXDIB_8bppMask))
     return nullptr;
-  }
+
   for (int row = rect.top; row < rect.bottom; row++) {
     const uint8_t* src_scan = GetScanline(row) + rect.left * 4 + 3;
     uint8_t* dest_scan = (uint8_t*)pMask->GetScanline(row - rect.top);

[dsinclair, 2016/12/14 21:39:05]

nit: static_cast

[Tom Sepez, 2016/12/14 22:05:05]

Actually, both of these are const_casts.
Done.

     for (int col = rect.left; col < rect.right; col++) {
       *dest_scan++ = *src_scan;
       src_scan += 4;
     }
   }
   return pMask;
 }
 
-bool CFX_DIBSource::CopyAlphaMask(const CFX_DIBSource* pAlphaMask,
-                                  const FX_RECT* pClip) {
-  if (!HasAlpha() || GetFormat() == FXDIB_Argb) {
+bool CFX_DIBSource::SetAlphaMask(const CFX_DIBSource* pAlphaMask,
+                                 const FX_RECT* pClip) {
+  if (!HasAlpha() || GetFormat() == FXDIB_Argb)
     return false;
+
+  if (!pAlphaMask) {
+    m_pAlphaMask->Clear(0xff000000);
+    return true;
   }
-  if (pAlphaMask) {
-    FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
-    if (pClip) {
-      rect.Intersect(*pClip);
-      if (rect.IsEmpty() || rect.Width() != m_Width ||
-          rect.Height() != m_Height) {
-        return false;
-      }
-    } else {
-      if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height) {
-        return false;
-      }
+  FX_RECT rect(0, 0, pAlphaMask->m_Width, pAlphaMask->m_Height);
+  if (pClip) {
+    rect.Intersect(*pClip);
+    if (rect.IsEmpty() || rect.Width() != m_Width ||
+        rect.Height() != m_Height) {
+      return false;
     }
-    for (int row = 0; row < m_Height; row++)
-      FXSYS_memcpy((void*)m_pAlphaMask->GetScanline(row),
-                   pAlphaMask->GetScanline(row + rect.top) + rect.left,
-                   m_pAlphaMask->m_Pitch);
   } else {
-    m_pAlphaMask->Clear(0xff000000);
+    if (pAlphaMask->m_Width != m_Width || pAlphaMask->m_Height != m_Height)
+      return false;
   }
+  for (int row = 0; row < m_Height; row++)

[dsinclair, 2016/12/14 21:39:05]

nit: {}s

[Tom Sepez, 2016/12/14 22:05:05]

much better. done.

+    FXSYS_memcpy((void*)m_pAlphaMask->GetScanline(row),

[dsinclair, 2016/12/14 21:39:05]

static_cast?

+                 pAlphaMask->GetScanline(row + rect.top) + rect.left,
+                 m_pAlphaMask->m_Pitch);
   return true;
 }
 
 const int g_ChannelOffset[] = {0, 2, 1, 0, 0, 1, 2, 3, 3};
 bool CFX_DIBitmap::LoadChannel(FXDIB_Channel destChannel,
                                CFX_DIBSource* pSrcBitmap,
                                FXDIB_Channel srcChannel) {
   if (!m_pBuffer)
     return false;
 
@@ skipping 673 matching lines @@
   }
   return true;
 }
 
 CFX_DIBitmap* CFX_DIBSource::FlipImage(bool bXFlip, bool bYFlip) const {
   CFX_DIBitmap* pFlipped = new CFX_DIBitmap;
   if (!pFlipped->Create(m_Width, m_Height, GetFormat())) {
     delete pFlipped;
     return nullptr;
   }
-  pFlipped->CopyPalette(m_pPalette.get());
+  pFlipped->SetPalette(m_pPalette.get());
   uint8_t* pDestBuffer = pFlipped->GetBuffer();
   int Bpp = m_bpp / 8;
   for (int row = 0; row < m_Height; row++) {
     const uint8_t* src_scan = GetScanline(row);
     uint8_t* dest_scan =
         pDestBuffer + m_Pitch * (bYFlip ? (m_Height - row - 1) : row);
     if (!bXFlip) {
       FXSYS_memcpy(dest_scan, src_scan, m_Pitch);
       continue;
     }
@@ skipping 53 matching lines @@
 }
 
 CFX_DIBExtractor::CFX_DIBExtractor(const CFX_DIBSource* pSrc) {
   if (pSrc->GetBuffer()) {
     m_pBitmap = pdfium::MakeUnique<CFX_DIBitmap>();
     if (!m_pBitmap->Create(pSrc->GetWidth(), pSrc->GetHeight(),
                            pSrc->GetFormat(), pSrc->GetBuffer())) {
       m_pBitmap.reset();
       return;
     }
-    m_pBitmap->CopyPalette(pSrc->GetPalette());
-    m_pBitmap->CopyAlphaMask(pSrc->m_pAlphaMask);
+    m_pBitmap->SetPalette(pSrc->GetPalette());
+    m_pBitmap->SetAlphaMask(pSrc->m_pAlphaMask);
   } else {
     m_pBitmap = pSrc->Clone();
   }
 }
 
 CFX_DIBExtractor::~CFX_DIBExtractor() {}
 
 CFX_FilteredDIB::CFX_FilteredDIB() : m_pSrc(nullptr) {}
 
 CFX_FilteredDIB::~CFX_FilteredDIB() {
@@ skipping 197 matching lines @@
 bool CFX_BitmapStorer::SetInfo(int width,
                                int height,
                                FXDIB_Format src_format,
                                uint32_t* pSrcPalette) {
   m_pBitmap = pdfium::MakeUnique<CFX_DIBitmap>();
   if (!m_pBitmap->Create(width, height, src_format)) {
     m_pBitmap.reset();
     return false;
   }
   if (pSrcPalette)
-    m_pBitmap->CopyPalette(pSrcPalette);
+    m_pBitmap->SetPalette(pSrcPalette);
   return true;
 }