Avoid the ptr.reset(new XXX()) anti-pattern

core/fpdfapi/page/fpdf_page_func.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/fpdfapi/page/pageint.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "core/fpdfapi/page/cpdf_psengine.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_simple_parser.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_stream_acc.h"
 #include "core/fxcrt/fx_safe_types.h"
+#include "third_party/base/ptr_util.h"
 
 namespace {
 
 struct PDF_PSOpName {
   const FX_CHAR* name;
   PDF_PSOP op;
 };
 
 const PDF_PSOpName kPsOpNames[] = {
     {"add", PSOP_ADD},         {"sub", PSOP_SUB},
@@ skipping 455 matching lines @@
 
   CPDF_Dictionary* pDict = pStream->GetDict();
   CPDF_Array* pSize = pDict->GetArrayFor("Size");
   CPDF_Array* pEncode = pDict->GetArrayFor("Encode");
   CPDF_Array* pDecode = pDict->GetArrayFor("Decode");
   m_nBitsPerSample = pDict->GetIntegerFor("BitsPerSample");
   if (!IsValidBitsPerSample(m_nBitsPerSample))
     return false;
 
   m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
-  m_pSampleStream.reset(new CPDF_StreamAcc);
+  m_pSampleStream = pdfium::MakeUnique<CPDF_StreamAcc>();
   m_pSampleStream->LoadAllData(pStream, false);
   FX_SAFE_UINT32 nTotalSampleBits = 1;
   m_EncodeInfo.resize(m_nInputs);
   for (uint32_t i = 0; i < m_nInputs; i++) {
     m_EncodeInfo[i].sizes = pSize ? pSize->GetIntegerAt(i) : 0;
     if (!pSize && i == 0)
       m_EncodeInfo[i].sizes = pDict->GetIntegerFor("Size");
     nTotalSampleBits *= m_EncodeInfo[i].sizes;
     if (pEncode) {
       m_EncodeInfo[i].encode_min = pEncode->GetFloatAt(i * 2);
@@ skipping 226 matching lines @@
     return pFunc;
 
   int iType = -1;
   if (CPDF_Stream* pStream = pFuncObj->AsStream())
     iType = pStream->GetDict()->GetIntegerFor("FunctionType");
   else if (CPDF_Dictionary* pDict = pFuncObj->AsDictionary())
     iType = pDict->GetIntegerFor("FunctionType");
 
   Type type = IntegerToFunctionType(iType);
   if (type == Type::kType0Sampled)
-    pFunc.reset(new CPDF_SampledFunc());
+    pFunc = pdfium::MakeUnique<CPDF_SampledFunc>();
   else if (type == Type::kType2ExpotentialInterpolation)
-    pFunc.reset(new CPDF_ExpIntFunc());
+    pFunc = pdfium::MakeUnique<CPDF_ExpIntFunc>();
   else if (type == Type::kType3Stitching)
-    pFunc.reset(new CPDF_StitchFunc());
+    pFunc = pdfium::MakeUnique<CPDF_StitchFunc>();
   else if (type == Type::kType4PostScript)
-    pFunc.reset(new CPDF_PSFunc());
+    pFunc = pdfium::MakeUnique<CPDF_PSFunc>();
 
   if (!pFunc || !pFunc->Init(pFuncObj))
     return nullptr;
 
   return pFunc;
 }
 
 // static
 CPDF_Function::Type CPDF_Function::IntegerToFunctionType(int iType) {
   switch (iType) {
@@ skipping 88 matching lines @@
   return m_Type == Type::kType2ExpotentialInterpolation
              ? static_cast<const CPDF_ExpIntFunc*>(this)
              : nullptr;
 }
 
 const CPDF_StitchFunc* CPDF_Function::ToStitchFunc() const {
   return m_Type == Type::kType3Stitching
              ? static_cast<const CPDF_StitchFunc*>(this)
              : nullptr;
 }