Use CFX_MaybeOwned<> in CPDF_Image

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 17 matching lines @@
 #include "core/fxge/fx_dib.h"
 #include "third_party/base/numerics/safe_conversions.h"
 #include "third_party/base/ptr_util.h"
 
 CPDF_Image::CPDF_Image(CPDF_Document* pDoc) : m_pDocument(pDoc) {}
 
 CPDF_Image::CPDF_Image(CPDF_Document* pDoc,
                        std::unique_ptr<CPDF_Stream> pStream)
     : m_bIsInline(true),
       m_pDocument(pDoc),
-      m_pStream(pStream.get()),
-      m_pOwnedStream(std::move(pStream)) {
-  m_pOwnedDict =
-      ToDictionary(std::unique_ptr<CPDF_Object>(m_pStream->GetDict()->Clone()));
-  m_pDict = m_pOwnedDict.get();
+      m_pStream(std::move(pStream)),
+      m_pDict(ToDictionary(m_pStream->GetDict()->Clone())) {
+  ASSERT(m_pStream.IsOwned());
+  ASSERT(m_pDict.IsOwned());
   FinishInitialization();
 }
 
 CPDF_Image::CPDF_Image(CPDF_Document* pDoc, uint32_t dwStreamObjNum)
     : m_pDocument(pDoc),
-      m_pStream(ToStream(pDoc->GetIndirectObject(dwStreamObjNum))) {
-  m_pDict = m_pStream->GetDict();
+      m_pStream(ToStream(pDoc->GetIndirectObject(dwStreamObjNum))),
+      m_pDict(m_pStream->GetDict()) {
+  ASSERT(!m_pStream.IsOwned());
+  ASSERT(!m_pDict.IsOwned());
   FinishInitialization();
 }
 
 CPDF_Image::~CPDF_Image() {}
 
 void CPDF_Image::FinishInitialization() {
   m_pOC = m_pDict->GetDictFor("OC");
   m_bIsMask =
       !m_pDict->KeyExist("ColorSpace") || m_pDict->GetIntegerFor("ImageMask");
   m_bInterpolate = !!m_pDict->GetIntegerFor("Interpolate");
   m_Height = m_pDict->GetIntegerFor("Height");
   m_Width = m_pDict->GetIntegerFor("Width");
 }
 
 void CPDF_Image::ConvertStreamToIndirectObject() {
   if (!m_pStream->IsInline())
     return;
 
-  ASSERT(m_pOwnedStream);
-  m_pDocument->AddIndirectObject(std::move(m_pOwnedStream));
+  ASSERT(m_pStream.IsOwned());
+  m_pDocument->AddIndirectObject(m_pStream.Release());
 }
 
 std::unique_ptr<CPDF_Dictionary> CPDF_Image::InitJPEG(uint8_t* pData,
                                                       uint32_t size) {
   int32_t width;
   int32_t height;
   int32_t num_comps;
   int32_t bits;
   bool color_trans;
   if (!CPDF_ModuleMgr::Get()->GetJpegModule()->LoadInfo(
@@ skipping 23 matching lines @@
   pDict->SetNewFor<CPDF_Name>("ColorSpace", csname);
   pDict->SetNewFor<CPDF_Number>("BitsPerComponent", bits);
   pDict->SetNewFor<CPDF_Name>("Filter", "DCTDecode");
   if (!color_trans) {
     CPDF_Dictionary* pParms = pDict->SetNewFor<CPDF_Dictionary>("DecodeParms");
     pParms->SetNewFor<CPDF_Number>("ColorTransform", 0);
   }
   m_bIsMask = false;
   m_Width = width;
   m_Height = height;
-  if (!m_pStream) {
-    m_pOwnedStream = pdfium::MakeUnique<CPDF_Stream>();
-    m_pStream = m_pOwnedStream.get();
-  }
+  if (!m_pStream)
+    m_pStream = pdfium::MakeUnique<CPDF_Stream>();
   return pDict;
 }
 
 void CPDF_Image::SetJpegImage(IFX_SeekableReadStream* pFile) {
   uint32_t size = pdfium::base::checked_cast<uint32_t>(pFile->GetSize());
   if (!size)
     return;
 
   uint32_t dwEstimateSize = std::min(size, 8192U);
   std::vector<uint8_t> data(dwEstimateSize);
@@ skipping 157 matching lines @@
         pDest[dest_offset + 1] = (uint8_t)(src_buf[src_offset + 1] * alpha);
         pDest[dest_offset + 2] = (uint8_t)(src_buf[src_offset] * alpha);
         dest_offset += 3;
         src_offset += bpp == 24 ? 3 : 4;
       }
 
       pDest += dest_pitch;
       dest_offset = 0;
     }
   }
-  if (!m_pStream) {
-    m_pOwnedStream = pdfium::MakeUnique<CPDF_Stream>();
-    m_pStream = m_pOwnedStream.get();
-  }
+  if (!m_pStream)
+    m_pStream = pdfium::MakeUnique<CPDF_Stream>();
+
   m_pStream->InitStream(dest_buf, dest_size, std::move(pDict));
   m_bIsMask = pBitmap->IsAlphaMask();
   m_Width = BitmapWidth;
   m_Height = BitmapHeight;
   FX_Free(dest_buf);
 }
 
 void CPDF_Image::ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pBitmap) {
-  pPage->GetRenderCache()->ResetBitmap(m_pStream, pBitmap);
+  pPage->GetRenderCache()->ResetBitmap(m_pStream.Get(), pBitmap);
 }
 
 CFX_DIBSource* CPDF_Image::LoadDIBSource(CFX_DIBSource** ppMask,
                                          uint32_t* pMatteColor,
                                          bool bStdCS,
                                          uint32_t GroupFamily,
                                          bool bLoadMask) const {
   auto source = pdfium::MakeUnique<CPDF_DIBSource>();
-  if (source->Load(m_pDocument, m_pStream,
+  if (source->Load(m_pDocument, m_pStream.Get(),
                    reinterpret_cast<CPDF_DIBSource**>(ppMask), pMatteColor,
                    nullptr, nullptr, bStdCS, GroupFamily, bLoadMask)) {
     return source.release();
   }
   return nullptr;
 }
 
 CFX_DIBSource* CPDF_Image::DetachBitmap() {
   CFX_DIBSource* pBitmap = m_pDIBSource;
   m_pDIBSource = nullptr;
   return pBitmap;
 }
 
 CFX_DIBSource* CPDF_Image::DetachMask() {
   CFX_DIBSource* pBitmap = m_pMask;
   m_pMask = nullptr;
   return pBitmap;
 }
 
 bool CPDF_Image::StartLoadDIBSource(CPDF_Dictionary* pFormResource,
                                     CPDF_Dictionary* pPageResource,
                                     bool bStdCS,
                                     uint32_t GroupFamily,
                                     bool bLoadMask) {
   auto source = pdfium::MakeUnique<CPDF_DIBSource>();
-  int ret =
-      source->StartLoadDIBSource(m_pDocument, m_pStream, true, pFormResource,
-                                 pPageResource, bStdCS, GroupFamily, bLoadMask);
+  int ret = source->StartLoadDIBSource(m_pDocument, m_pStream.Get(), true,
+                                       pFormResource, pPageResource, bStdCS,
+                                       GroupFamily, bLoadMask);
   if (ret == 2) {
     m_pDIBSource = source.release();
     return true;
   }
   if (!ret) {
     m_pDIBSource = nullptr;
     return false;
   }
   m_pMask = source->DetachMask();
   m_MatteColor = source->GetMatteColor();
   m_pDIBSource = source.release();
   return false;
 }
 
 bool CPDF_Image::Continue(IFX_Pause* pPause) {
   CPDF_DIBSource* pSource = static_cast<CPDF_DIBSource*>(m_pDIBSource);
   int ret = pSource->ContinueLoadDIBSource(pPause);
   if (ret == 2) {
     return true;
   }
   if (!ret) {
     delete m_pDIBSource;
     m_pDIBSource = nullptr;
     return false;
   }
   m_pMask = pSource->DetachMask();
   m_MatteColor = pSource->GetMatteColor();
   return false;
 }