Revert "Remove FX_Alloc() null checks now that it can't return NULL."

core/src/fxcodec/codec/fx_codec_flate.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 "../../../../third_party/base/nonstd_unique_ptr.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../fx_zlib.h"
 #include "codec_int.h"
@@ skipping 565 matching lines @@
         }
         TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
     }
     return TRUE;
 }
 class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_FlateScanlineDecoder();
     ~CCodec_FlateScanlineDecoder();
-    void Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc,
-                int predictor, int Colors, int BitsPerComponent, int Columns);
+    FX_BOOL             Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc,
+                       int predictor, int Colors, int BitsPerComponent, int Columns);
     virtual void                Destroy()
     {
         delete this;
     }
     virtual void                v_DownScale(int dest_width, int dest_height) {}
     virtual FX_BOOL             v_Rewind();
     virtual FX_LPBYTE   v_GetNextLine();
     virtual FX_DWORD    GetSrcOffset();
     void*                               m_pFlate;
     FX_LPCBYTE                  m_SrcBuf;
@@ skipping 25 matching lines @@
     if (m_pPredictBuffer) {
         FX_Free(m_pPredictBuffer);
     }
     if (m_pPredictRaw) {
         FX_Free(m_pPredictRaw);
     }
     if (m_pFlate) {
         FPDFAPI_FlateEnd(m_pFlate);
     }
 }
-void CCodec_FlateScanlineDecoder::Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
+FX_BOOL CCodec_FlateScanlineDecoder::Create(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns)
 {
     m_SrcBuf = src_buf;
     m_SrcSize = src_size;
     m_OutputWidth = m_OrigWidth = width;
     m_OutputHeight = m_OrigHeight = height;
     m_nComps = nComps;
     m_bpc = bpc;
     m_bColorTransformed = FALSE;
     m_Pitch = (width * nComps * bpc + 7) / 8;
     m_pScanline = FX_Alloc(FX_BYTE, m_Pitch);
+    if (m_pScanline == NULL) {
+        return FALSE;
+    }
     m_Predictor = 0;
     if (predictor) {
         if (predictor >= 10) {
             m_Predictor = 2;
         } else if (predictor == 2) {
             m_Predictor = 1;
         }
         if (m_Predictor) {
             if (BitsPerComponent * Colors * Columns == 0) {
                 BitsPerComponent = m_bpc;
                 Colors = m_nComps;
                 Columns = m_OrigWidth;
             }
             m_Colors = Colors;
             m_BitsPerComponent = BitsPerComponent;
             m_Columns = Columns;
             m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8;
             m_pLastLine = FX_Alloc(FX_BYTE, m_PredictPitch);
+            if (m_pLastLine == NULL) {
+                return FALSE;
+            }
             m_pPredictRaw = FX_Alloc(FX_BYTE, m_PredictPitch + 1);
+            if (m_pPredictRaw == NULL) {
+                return FALSE;
+            }
             m_pPredictBuffer = FX_Alloc(FX_BYTE, m_PredictPitch);
+            if (m_pPredictBuffer == NULL) {
+                return FALSE;
+            }
         }
     }
+    return TRUE;
 }
 FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind()
 {
     if (m_pFlate) {
         FPDFAPI_FlateEnd(m_pFlate);
     }
     m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
     if (m_pFlate == NULL) {
         return FALSE;
     }
@@ skipping 55 matching lines @@
     if (guess_size > kMaxInitialAllocSize) {
         guess_size = kMaxInitialAllocSize;
         alloc_step = kMaxInitialAllocSize;
     }
     FX_DWORD buf_size = guess_size;
     FX_DWORD last_buf_size = buf_size;
     void* context = nullptr;
 
     FX_LPBYTE guess_buf = FX_Alloc(FX_BYTE, guess_size + 1);
     FX_LPBYTE cur_buf = guess_buf;
+    if (!guess_buf)
+        goto fail;
     guess_buf[guess_size] = '\0';
     context = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
     if (!context)
         goto fail;
     FPDFAPI_FlateInput(context, src_buf, src_size);
     if (useOldImpl) {
         while (1) {
             FX_INT32 ret = FPDFAPI_FlateOutput(context, cur_buf, buf_size);
             if (ret != Z_OK)
                 break;
@@ skipping 35 matching lines @@
             }
             if (avail_buf_size != 0) {
                 last_buf_size = buf_size - avail_buf_size;
                 result_tmp_bufs.Add(cur_buf);
                 break;
             }
 
             // |avail_buf_size| == 0 case.
             result_tmp_bufs.Add(cur_buf);
             cur_buf = FX_Alloc(FX_BYTE, buf_size + 1);
+            if (!cur_buf) {
+                for (FX_INT32 i = 0; i < result_tmp_bufs.GetSize(); i++) {
+                    FX_Free(result_tmp_bufs[i]);
+                }
+                goto fail;
+            }
             cur_buf[buf_size] = '\0';
         }
         dest_size = FPDFAPI_FlateGetTotalOut(context);
         offset = FPDFAPI_FlateGetTotalIn(context);
         if (result_tmp_bufs.GetSize() == 1) {
             dest_buf = result_tmp_bufs[0];
         } else {
             FX_LPBYTE result_buf = FX_Alloc(FX_BYTE, dest_size);
+            if (!result_buf) {
+                for (FX_INT32 i = 0; i < result_tmp_bufs.GetSize(); i++) {
+                    FX_Free(result_tmp_bufs[i]);
+                }
+                goto fail;
+            }
             FX_DWORD result_pos = 0;
             for (FX_INT32 i = 0; i < result_tmp_bufs.GetSize(); i++) {
                 FX_LPBYTE tmp_buf = result_tmp_bufs[i];
                 FX_DWORD tmp_buf_size = buf_size;
                 if (i == result_tmp_bufs.GetSize() - 1) {
                     tmp_buf_size = last_buf_size;
                 }
                 FXSYS_memcpy32(result_buf + result_pos, tmp_buf, tmp_buf_size);
                 result_pos += tmp_buf_size;
                 FX_Free(result_tmp_bufs[i]);
@@ skipping 38 matching lines @@
             offset = src_size;
             int err = decoder->Decode(NULL, dest_size, src_buf, offset,
                                       bEarlyChange);
             if (err || dest_size == 0 || dest_size + 1 < dest_size) {
                 return -1;
             }
         }
         {
             nonstd::unique_ptr<CLZWDecoder> decoder(new CLZWDecoder);
             dest_buf = FX_Alloc( FX_BYTE, dest_size + 1);
+            if (dest_buf == NULL) {
+                return -1;
+            }
             dest_buf[dest_size] = '\0';
             decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
         }
     } else {
         FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size, offset);
     }
     if (predictor_type == 0) {
         return offset;
     }
     FX_BOOL ret = TRUE;
     if (predictor_type == 2) {
         ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                             Columns);
     } else if (predictor_type == 1) {
         ret = TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                              Columns);
     }
     return ret ? offset : -1;
 }
 FX_BOOL CCodec_FlateModule::Encode(const FX_BYTE* src_buf, FX_DWORD src_size,
                                    int predictor, int Colors, int BitsPerComponent, int Columns,
                                    FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     if (predictor != 2 && predictor < 10) {
         return Encode(src_buf, src_size, dest_buf, dest_size);
     }
     FX_LPBYTE pSrcBuf = NULL;
     pSrcBuf = FX_Alloc(FX_BYTE, src_size);
+    if (pSrcBuf == NULL) {
+        return FALSE;
+    }
     FXSYS_memcpy32(pSrcBuf, src_buf, src_size);
     FX_BOOL ret = TRUE;
     if (predictor == 2) {
         ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
                                    Columns);
     } else if (predictor >= 10) {
         ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
                                   BitsPerComponent, Columns);
     }
     if (ret)
         ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
     FX_Free(pSrcBuf);
     return ret;
 }
 FX_BOOL CCodec_FlateModule::Encode(FX_LPCBYTE src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
 {
     dest_size = src_size + src_size / 1000 + 12;
     dest_buf = FX_Alloc( FX_BYTE, dest_size);
+    if (dest_buf == NULL) {
+        return FALSE;
+    }
     unsigned long temp_size = dest_size;
     FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
     dest_size = (FX_DWORD)temp_size;
     return TRUE;
 }