Return unique_ptr<>s from fxcodec/

core/fpdfapi/page/cpdf_streamparser.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_streamparser.h"
 
 #include <limits.h>
 
 #include <memory>
 #include <utility>
 
 #include "core/fpdfapi/cpdf_modulemgr.h"
 #include "core/fpdfapi/page/cpdf_docpagedata.h"
 #include "core/fpdfapi/parser/cpdf_array.h"
 #include "core/fpdfapi/parser/cpdf_boolean.h"
 #include "core/fpdfapi/parser/cpdf_dictionary.h"
 #include "core/fpdfapi/parser/cpdf_document.h"
 #include "core/fpdfapi/parser/cpdf_name.h"
 #include "core/fpdfapi/parser/cpdf_null.h"
 #include "core/fpdfapi/parser/cpdf_number.h"
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_string.h"
 #include "core/fpdfapi/parser/fpdf_parser_decode.h"
 #include "core/fpdfapi/parser/fpdf_parser_utility.h"
 #include "core/fxcodec/fx_codec.h"
 #include "core/fxcrt/fx_ext.h"
 
-CCodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(

[Tom Sepez, 2016/12/13 19:21:19]

Note: moved to .h, sheesh.

-    const uint8_t* src_buf,
-    uint32_t src_size,
-    int width,
-    int height,
-    const CPDF_Dictionary* pParams);
-
 namespace {
 
 const uint32_t kMaxNestedArrayLevel = 512;
 const uint32_t kMaxWordBuffer = 256;
 const FX_STRSIZE kMaxStringLength = 32767;
 
-uint32_t DecodeAllScanlines(CCodec_ScanlineDecoder* pDecoder,
+uint32_t DecodeAllScanlines(std::unique_ptr<CCodec_ScanlineDecoder> pDecoder,
                             uint8_t*& dest_buf,
                             uint32_t& dest_size) {
   if (!pDecoder)
     return FX_INVALID_OFFSET;
   int ncomps = pDecoder->CountComps();
   int bpc = pDecoder->GetBPC();
   int width = pDecoder->GetWidth();
   int height = pDecoder->GetHeight();
   int pitch = (width * ncomps * bpc + 7) / 8;
-  if (height == 0 || pitch > (1 << 30) / height) {
-    delete pDecoder;
+  if (height == 0 || pitch > (1 << 30) / height)
     return FX_INVALID_OFFSET;
-  }
+
   dest_buf = FX_Alloc2D(uint8_t, pitch, height);
   dest_size = pitch * height;  // Safe since checked alloc returned.
   for (int row = 0; row < height; row++) {
     const uint8_t* pLine = pDecoder->GetScanline(row);
     if (!pLine)
       break;
 
     FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch);
   }
-  uint32_t srcoff = pDecoder->GetSrcOffset();
-  delete pDecoder;
-  return srcoff;
+  return pDecoder->GetSrcOffset();
 }
 
 uint32_t PDF_DecodeInlineStream(const uint8_t* src_buf,
                                 uint32_t limit,
                                 int width,
                                 int height,
                                 CFX_ByteString& decoder,
                                 CPDF_Dictionary* pParam,
                                 uint8_t*& dest_buf,
                                 uint32_t& dest_size) {
   if (decoder == "CCITTFaxDecode" || decoder == "CCF") {
-    CCodec_ScanlineDecoder* pDecoder =
+    std::unique_ptr<CCodec_ScanlineDecoder> pDecoder =
         FPDFAPI_CreateFaxDecoder(src_buf, limit, width, height, pParam);
-    return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
+    return DecodeAllScanlines(std::move(pDecoder), dest_buf, dest_size);
   }
   if (decoder == "ASCII85Decode" || decoder == "A85")
     return A85Decode(src_buf, limit, dest_buf, dest_size);
   if (decoder == "ASCIIHexDecode" || decoder == "AHx")
     return HexDecode(src_buf, limit, dest_buf, dest_size);
   if (decoder == "FlateDecode" || decoder == "Fl") {
     return FPDFAPI_FlateOrLZWDecode(false, src_buf, limit, pParam, dest_size,
                                     dest_buf, dest_size);
   }
   if (decoder == "LZWDecode" || decoder == "LZW") {
     return FPDFAPI_FlateOrLZWDecode(true, src_buf, limit, pParam, 0, dest_buf,
                                     dest_size);
   }
   if (decoder == "DCTDecode" || decoder == "DCT") {
-    CCodec_ScanlineDecoder* pDecoder =
+    std::unique_ptr<CCodec_ScanlineDecoder> pDecoder =
         CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
             src_buf, limit, width, height, 0,
             !pParam || pParam->GetIntegerFor("ColorTransform", 1));
-    return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
+    return DecodeAllScanlines(std::move(pDecoder), dest_buf, dest_size);
   }
   if (decoder == "RunLengthDecode" || decoder == "RL")
     return RunLengthDecode(src_buf, limit, dest_buf, dest_size);
   dest_size = 0;
   dest_buf = 0;
   return (uint32_t)-1;
 }
 
 }  // namespace
 
@@ skipping 493 matching lines @@
 
   if (buf.GetLength() > kMaxStringLength)
     return CFX_ByteString(buf.GetBuffer(), kMaxStringLength);
 
   return buf.MakeString();
 }
 
 bool CPDF_StreamParser::PositionIsInBounds() const {
   return m_Pos < m_Size;
 }