Remove FX_BOOL from core

core/fxcodec/codec/fx_codec_jpeg.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 <setjmp.h>
 
 #include "core/fxcodec/codec/codec_int.h"
 #include "core/fxcodec/fx_codec.h"
@@ skipping 108 matching lines @@
   src.skip_input_data = _src_skip_data;
   src.fill_input_buffer = _src_fill_buffer;
   src.resync_to_restart = _src_resync;
   src.bytes_in_buffer = src_size;
   src.next_input_byte = src_buf;
   cinfo.src = &src;
   if (setjmp(mark) == -1) {
     jpeg_destroy_decompress(&cinfo);
     return false;
   }
-  int ret = jpeg_read_header(&cinfo, TRUE);
+  int ret = jpeg_read_header(&cinfo, true);
   if (ret != JPEG_HEADER_OK) {
     jpeg_destroy_decompress(&cinfo);
     return false;
   }
   *width = cinfo.image_width;
   *height = cinfo.image_height;
   *num_components = cinfo.num_components;
   *color_transform =
       cinfo.jpeg_color_space == JCS_YCbCr || cinfo.jpeg_color_space == JCS_YCCK;
   *bits_per_components = cinfo.data_precision;
   jpeg_destroy_decompress(&cinfo);
   return true;
 }
 
 class CCodec_JpegDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_JpegDecoder();
   ~CCodec_JpegDecoder() override;
 
-  FX_BOOL Create(const uint8_t* src_buf,
-                 uint32_t src_size,
-                 int width,
-                 int height,
-                 int nComps,
-                 FX_BOOL ColorTransform);
+  bool Create(const uint8_t* src_buf,
+              uint32_t src_size,
+              int width,
+              int height,
+              int nComps,
+              bool ColorTransform);
 
   // CCodec_ScanlineDecoder
-  FX_BOOL v_Rewind() override;
+  bool v_Rewind() override;
   uint8_t* v_GetNextLine() override;
   uint32_t GetSrcOffset() override;
 
-  FX_BOOL InitDecode();
+  bool InitDecode();
 
   jmp_buf m_JmpBuf;
   struct jpeg_decompress_struct cinfo;
   struct jpeg_error_mgr jerr;
   struct jpeg_source_mgr src;
   const uint8_t* m_SrcBuf;
   uint32_t m_SrcSize;
   uint8_t* m_pScanlineBuf;
 
-  FX_BOOL m_bInited;
-  FX_BOOL m_bStarted;
-  FX_BOOL m_bJpegTransform;
+  bool m_bInited;
+  bool m_bStarted;
+  bool m_bJpegTransform;
 
  protected:
   uint32_t m_nDefaultScaleDenom;
 };
 
 CCodec_JpegDecoder::CCodec_JpegDecoder() {
   m_pScanlineBuf = nullptr;
-  m_bStarted = FALSE;
-  m_bInited = FALSE;
+  m_bStarted = false;
+  m_bInited = false;
   FXSYS_memset(&cinfo, 0, sizeof(cinfo));
   FXSYS_memset(&jerr, 0, sizeof(jerr));
   FXSYS_memset(&src, 0, sizeof(src));
   m_nDefaultScaleDenom = 1;
 }
 
 CCodec_JpegDecoder::~CCodec_JpegDecoder() {
   FX_Free(m_pScanlineBuf);
   if (m_bInited)
     jpeg_destroy_decompress(&cinfo);
 }
 
-FX_BOOL CCodec_JpegDecoder::InitDecode() {
+bool CCodec_JpegDecoder::InitDecode() {
   cinfo.err = &jerr;
   cinfo.client_data = &m_JmpBuf;
   if (setjmp(m_JmpBuf) == -1)
-    return FALSE;
+    return false;
 
   jpeg_create_decompress(&cinfo);
-  m_bInited = TRUE;
+  m_bInited = true;
   cinfo.src = &src;
   src.bytes_in_buffer = m_SrcSize;
   src.next_input_byte = m_SrcBuf;
   if (setjmp(m_JmpBuf) == -1) {
     jpeg_destroy_decompress(&cinfo);
-    m_bInited = FALSE;
-    return FALSE;
+    m_bInited = false;
+    return false;
   }
   cinfo.image_width = m_OrigWidth;
   cinfo.image_height = m_OrigHeight;
-  int ret = jpeg_read_header(&cinfo, TRUE);
+  int ret = jpeg_read_header(&cinfo, true);
   if (ret != JPEG_HEADER_OK)
-    return FALSE;
+    return false;
 
   if (cinfo.saw_Adobe_marker)
-    m_bJpegTransform = TRUE;
+    m_bJpegTransform = true;
 
   if (cinfo.num_components == 3 && !m_bJpegTransform)
     cinfo.out_color_space = cinfo.jpeg_color_space;
 
   m_OrigWidth = cinfo.image_width;
   m_OrigHeight = cinfo.image_height;
   m_OutputWidth = m_OrigWidth;
   m_OutputHeight = m_OrigHeight;
   m_nDefaultScaleDenom = cinfo.scale_denom;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CCodec_JpegDecoder::Create(const uint8_t* src_buf,
-                                   uint32_t src_size,
-                                   int width,
-                                   int height,
-                                   int nComps,
-                                   FX_BOOL ColorTransform) {
+bool CCodec_JpegDecoder::Create(const uint8_t* src_buf,
+                                uint32_t src_size,
+                                int width,
+                                int height,
+                                int nComps,
+                                bool ColorTransform) {
   JpegScanSOI(&src_buf, &src_size);
   m_SrcBuf = src_buf;
   m_SrcSize = src_size;
   jerr.error_exit = _error_fatal;
   jerr.emit_message = _error_do_nothing1;
   jerr.output_message = _error_do_nothing;
   jerr.format_message = _error_do_nothing2;
   jerr.reset_error_mgr = _error_do_nothing;
   src.init_source = _src_do_nothing;
   src.term_source = _src_do_nothing;
   src.skip_input_data = _src_skip_data;
   src.fill_input_buffer = _src_fill_buffer;
   src.resync_to_restart = _src_resync;
   m_bJpegTransform = ColorTransform;
   if (src_size > 1 &&
       FXSYS_memcmp(src_buf + src_size - 2, "\xFF\xD9", 2) != 0) {
     ((uint8_t*)src_buf)[src_size - 2] = 0xFF;
     ((uint8_t*)src_buf)[src_size - 1] = 0xD9;
   }
   m_OutputWidth = m_OrigWidth = width;
   m_OutputHeight = m_OrigHeight = height;
   if (!InitDecode())
-    return FALSE;
+    return false;
 
   if (cinfo.num_components < nComps)
-    return FALSE;
+    return false;
 
   if ((int)cinfo.image_width < width)
-    return FALSE;
+    return false;
 
   m_Pitch =
       (static_cast<uint32_t>(cinfo.image_width) * cinfo.num_components + 3) /
       4 * 4;
   m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
   m_nComps = cinfo.num_components;
   m_bpc = 8;
-  m_bStarted = FALSE;
-  return TRUE;
+  m_bStarted = false;
+  return true;
 }
 
-FX_BOOL CCodec_JpegDecoder::v_Rewind() {
+bool CCodec_JpegDecoder::v_Rewind() {
   if (m_bStarted) {
     jpeg_destroy_decompress(&cinfo);
     if (!InitDecode()) {
-      return FALSE;
+      return false;
     }
   }
   if (setjmp(m_JmpBuf) == -1) {
-    return FALSE;
+    return false;
   }
   cinfo.scale_denom = m_nDefaultScaleDenom;
   m_OutputWidth = m_OrigWidth;
   m_OutputHeight = m_OrigHeight;
   if (!jpeg_start_decompress(&cinfo)) {
     jpeg_destroy_decompress(&cinfo);
-    return FALSE;
+    return false;
   }
   if ((int)cinfo.output_width > m_OrigWidth) {
-    ASSERT(FALSE);
-    return FALSE;
+    ASSERT(false);
+    return false;
   }
-  m_bStarted = TRUE;
-  return TRUE;
+  m_bStarted = true;
+  return true;
 }
 
 uint8_t* CCodec_JpegDecoder::v_GetNextLine() {
   if (setjmp(m_JmpBuf) == -1)
     return nullptr;
 
   int nlines = jpeg_read_scanlines(&cinfo, &m_pScanlineBuf, 1);
   return nlines > 0 ? m_pScanlineBuf : nullptr;
 }
 
 uint32_t CCodec_JpegDecoder::GetSrcOffset() {
   return (uint32_t)(m_SrcSize - src.bytes_in_buffer);
 }
 
-CCodec_ScanlineDecoder* CCodec_JpegModule::CreateDecoder(
-    const uint8_t* src_buf,
-    uint32_t src_size,
-    int width,
-    int height,
-    int nComps,
-    FX_BOOL ColorTransform) {
+CCodec_ScanlineDecoder* CCodec_JpegModule::CreateDecoder(const uint8_t* src_buf,
+                                                         uint32_t src_size,
+                                                         int width,
+                                                         int height,
+                                                         int nComps,
+                                                         bool ColorTransform) {
   if (!src_buf || src_size == 0)
     return nullptr;
 
   std::unique_ptr<CCodec_JpegDecoder> pDecoder(new CCodec_JpegDecoder);
   if (!pDecoder->Create(src_buf, src_size, width, height, nComps,
                         ColorTransform)) {
     return nullptr;
   }
   return pDecoder.release();
 }
@@ skipping 111 matching lines @@
 
   *width = ctx->m_Info.image_width;
   *height = ctx->m_Info.image_height;
   *nComps = ctx->m_Info.num_components;
 #ifdef PDF_ENABLE_XFA
   JpegLoadAttribute(&ctx->m_Info, pAttribute);
 #endif
   return 0;
 }
 
-FX_BOOL CCodec_JpegModule::StartScanline(FXJPEG_Context* ctx, int down_scale) {
+bool CCodec_JpegModule::StartScanline(FXJPEG_Context* ctx, int down_scale) {
   if (setjmp(ctx->m_JumpMark) == -1)
-    return FALSE;
+    return false;
 
   ctx->m_Info.scale_denom = down_scale;
   return !!jpeg_start_decompress(&ctx->m_Info);
 }
 
-FX_BOOL CCodec_JpegModule::ReadScanline(FXJPEG_Context* ctx,
-                                        unsigned char* dest_buf) {
+bool CCodec_JpegModule::ReadScanline(FXJPEG_Context* ctx,
+                                     unsigned char* dest_buf) {
   if (setjmp(ctx->m_JumpMark) == -1)
-    return FALSE;
+    return false;
 
   int nlines = jpeg_read_scanlines(&ctx->m_Info, &dest_buf, 1);
   return nlines == 1;
 }
 
 uint32_t CCodec_JpegModule::GetAvailInput(FXJPEG_Context* ctx,
                                           uint8_t** avail_buf_ptr) {
   if (avail_buf_ptr) {
     *avail_buf_ptr = nullptr;
     if (ctx->m_SrcMgr.bytes_in_buffer > 0) {
       *avail_buf_ptr = (uint8_t*)ctx->m_SrcMgr.next_input_byte;
     }
   }
   return (uint32_t)ctx->m_SrcMgr.bytes_in_buffer;
 }