Clean up fx_codec_fax.cpp.

core/fpdfapi/fpdf_parser/fpdf_parser_decode.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/fpdf_parser/include/fpdf_parser_decode.h"
 
 #include <limits.h>
+
+#include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "core/fpdfapi/fpdf_parser/fpdf_parser_utility.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/include/cpdf_modulemgr.h"
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "third_party/base/stl_util.h"
 
-#define _STREAM_MAX_SIZE_ 20 * 1024 * 1024
+namespace {
+
+const uint32_t kMaxStreamSize = 20 * 1024 * 1024;
+
+bool CheckFlateDecodeParams(int Colors, int BitsPerComponent, int Columns) {
+  if (Colors < 0 || BitsPerComponent < 0 || Columns < 0)
+    return false;
+
+  int check = Columns;
+  if (check > 0 && Colors > INT_MAX / check)
+    return false;
+
+  check *= Colors;
+  if (check > 0 && BitsPerComponent > INT_MAX / check)
+    return false;
+
+  return check * BitsPerComponent <= INT_MAX - 7;
+}
+
+}  // namespace
 
 const uint16_t PDFDocEncoding[256] = {
     0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
     0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 0x0010, 0x0011,
     0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x02d8, 0x02c7, 0x02c6,
     0x02d9, 0x02dd, 0x02db, 0x02da, 0x02dc, 0x0020, 0x0021, 0x0022, 0x0023,
     0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c,
     0x002d, 0x002e, 0x002f, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
     0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e,
     0x003f, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
@@ skipping 132 matching lines @@
   if (!bFirst)
     dest_size++;
   return i;
 }
 
 uint32_t RunLengthDecode(const uint8_t* src_buf,
                          uint32_t src_size,
                          uint8_t*& dest_buf,
                          uint32_t& dest_size) {
   uint32_t i = 0;
-  uint32_t old;
   dest_size = 0;
   while (i < src_size) {
+    if (src_buf[i] == 128)
+      break;
+
+    uint32_t old = dest_size;
     if (src_buf[i] < 128) {
-      old = dest_size;
       dest_size += src_buf[i] + 1;
       if (dest_size < old)
         return FX_INVALID_OFFSET;
       i += src_buf[i] + 2;
-    } else if (src_buf[i] > 128) {
-      old = dest_size;
+    } else {
       dest_size += 257 - src_buf[i];
       if (dest_size < old)
         return FX_INVALID_OFFSET;
       i += 2;
-    } else {
-      break;
     }
   }
-  if (dest_size >= _STREAM_MAX_SIZE_)
+  if (dest_size >= kMaxStreamSize)
     return FX_INVALID_OFFSET;
+
   dest_buf = FX_Alloc(uint8_t, dest_size);
   i = 0;
   int dest_count = 0;
   while (i < src_size) {
+    if (src_buf[i] == 128)
+      break;
+
     if (src_buf[i] < 128) {
       uint32_t copy_len = src_buf[i] + 1;
       uint32_t buf_left = src_size - i - 1;
       if (buf_left < copy_len) {
         uint32_t delta = copy_len - buf_left;
         copy_len = buf_left;
         FXSYS_memset(dest_buf + dest_count + copy_len, '\0', delta);
       }
       FXSYS_memcpy(dest_buf + dest_count, src_buf + i + 1, copy_len);
       dest_count += src_buf[i] + 1;
       i += src_buf[i] + 2;
-    } else if (src_buf[i] > 128) {
+    } else {
       int fill = 0;
       if (i < src_size - 1) {
         fill = src_buf[i + 1];
       }
       FXSYS_memset(dest_buf + dest_count, fill, 257 - src_buf[i]);
       dest_count += 257 - src_buf[i];
       i += 2;
-    } else {
-      break;
     }
   }
-  uint32_t ret = i + 1;
-  if (ret > src_size) {
-    ret = src_size;
-  }
-  return ret;
+
+  return std::min(i + 1, src_size);
 }
 
 CCodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
     uint32_t src_size,
     int width,
     int height,
     const CPDF_Dictionary* pParams) {
   int K = 0;
-  FX_BOOL EndOfLine = FALSE;
-  FX_BOOL ByteAlign = FALSE;
-  FX_BOOL BlackIs1 = FALSE;
+  bool EndOfLine = false;
+  bool ByteAlign = false;
+  bool BlackIs1 = false;
   int Columns = 1728;
   int Rows = 0;
   if (pParams) {
     K = pParams->GetIntegerFor("K");
-    EndOfLine = pParams->GetIntegerFor("EndOfLine");
-    ByteAlign = pParams->GetIntegerFor("EncodedByteAlign");
-    BlackIs1 = pParams->GetIntegerFor("BlackIs1");
+    EndOfLine = !!pParams->GetIntegerFor("EndOfLine");
+    ByteAlign = !!pParams->GetIntegerFor("EncodedByteAlign");
+    BlackIs1 = !!pParams->GetIntegerFor("BlackIs1");
     Columns = pParams->GetIntegerFor("Columns", 1728);
     Rows = pParams->GetIntegerFor("Rows");
     if (Rows > USHRT_MAX) {
       Rows = 0;
     }
   }
   return CPDF_ModuleMgr::Get()->GetFaxModule()->CreateDecoder(
       src_buf, src_size, width, height, K, EndOfLine, ByteAlign, BlackIs1,
       Columns, Rows);
 }
 
-static FX_BOOL CheckFlateDecodeParams(int Colors,
-                                      int BitsPerComponent,
-                                      int Columns) {
-  if (Columns < 0) {
-    return FALSE;
-  }
-  int check = Columns;
-  if (Colors < 0 || (check > 0 && Colors > INT_MAX / check)) {
-    return FALSE;
-  }
-  check *= Colors;
-  if (BitsPerComponent < 0 ||
-      (check > 0 && BitsPerComponent > INT_MAX / check)) {
-    return FALSE;
-  }
-  check *= BitsPerComponent;
-  if (check > INT_MAX - 7) {
-    return FALSE;
-  }
-  return TRUE;
-}
-
 CCodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
     uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     const CPDF_Dictionary* pParams) {
   int predictor = 0;
   int Colors = 0, BitsPerComponent = 0, Columns = 0;
@@ skipping 280 matching lines @@
                      uint32_t src_size,
                      uint8_t*& dest_buf,
                      uint32_t& dest_size) {
   CCodec_ModuleMgr* pEncoders = CPDF_ModuleMgr::Get()->GetCodecModule();
   if (pEncoders) {
     return pEncoders->GetFlateModule()->FlateOrLZWDecode(
         FALSE, src_buf, src_size, FALSE, 0, 0, 0, 0, 0, dest_buf, dest_size);
   }
   return 0;
 }