Change some ints to bools in JBIG2 code.

core/fxcodec/jbig2/JBig2_Context.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/fxcodec/jbig2/JBig2_Context.h"
 
 #include <algorithm>
 #include <list>
@@ skipping 12 matching lines @@
 #include "core/fxcodec/jbig2/JBig2_SddProc.h"
 #include "core/fxcodec/jbig2/JBig2_TrdProc.h"
 #include "third_party/base/stl_util.h"
 
 namespace {
 
 size_t GetHuffContextSize(uint8_t val) {
   return val == 0 ? 65536 : val == 1 ? 8192 : 1024;
 }
 
-size_t GetRefAggContextSize(FX_BOOL val) {
+size_t GetRefAggContextSize(bool val) {
   return val ? 1024 : 8192;
 }
 
 }  // namespace
 
 // Implement a very small least recently used (LRU) cache. It is very
 // common for a JBIG2 dictionary to span multiple pages in a PDF file,
 // and we do not want to decode the same dictionary over and over
 // again. We key off of the memory location of the dictionary. The
 // list keeps track of the freshness of entries, with freshest ones
@@ skipping 377 matching lines @@
 int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment* pSegment,
                                         IFX_Pause* pPause) {
   uint16_t wFlags;
   if (m_pStream->readShortInteger(&wFlags) != 0)
     return JBIG2_ERROR_TOO_SHORT;
 
   std::unique_ptr<CJBig2_SDDProc> pSymbolDictDecoder(new CJBig2_SDDProc);
   pSymbolDictDecoder->SDHUFF = wFlags & 0x0001;
   pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001;
   pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003;
-  pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003;
+  pSymbolDictDecoder->SDRTEMPLATE = !!((wFlags >> 12) & 0x0003);
   uint8_t cSDHUFFDH = (wFlags >> 2) & 0x0003;
   uint8_t cSDHUFFDW = (wFlags >> 4) & 0x0003;
   uint8_t cSDHUFFBMSIZE = (wFlags >> 6) & 0x0001;
   uint8_t cSDHUFFAGGINST = (wFlags >> 7) & 0x0001;
   if (pSymbolDictDecoder->SDHUFF == 0) {
     const uint32_t dwTemp = (pSymbolDictDecoder->SDTEMPLATE == 0) ? 8 : 2;
     for (uint32_t i = 0; i < dwTemp; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
   }
-  if (pSymbolDictDecoder->SDREFAGG == 1 &&
-      pSymbolDictDecoder->SDRTEMPLATE == 0) {
+  if (pSymbolDictDecoder->SDREFAGG == 1 && !pSymbolDictDecoder->SDRTEMPLATE) {
     for (int32_t i = 0; i < 4; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pSymbolDictDecoder->SDRAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
   }
   if (m_pStream->readInteger(&pSymbolDictDecoder->SDNUMEXSYMS) != 0 ||
       m_pStream->readInteger(&pSymbolDictDecoder->SDNUMNEWSYMS) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
   if (pSymbolDictDecoder->SDNUMEXSYMS > JBIG2_MAX_EXPORT_SYSMBOLS ||
@@ skipping 198 matching lines @@
   uint32_t dwTemp = (wFlags >> 2) & 0x0003;
   pTRD->SBSTRIPS = 1 << dwTemp;
   pTRD->REFCORNER = (JBig2Corner)((wFlags >> 4) & 0x0003);
   pTRD->TRANSPOSED = (wFlags >> 6) & 0x0001;
   pTRD->SBCOMBOP = (JBig2ComposeOp)((wFlags >> 7) & 0x0003);
   pTRD->SBDEFPIXEL = (wFlags >> 9) & 0x0001;
   pTRD->SBDSOFFSET = (wFlags >> 10) & 0x001f;
   if (pTRD->SBDSOFFSET >= 0x0010) {
     pTRD->SBDSOFFSET = pTRD->SBDSOFFSET - 0x0020;
   }
-  pTRD->SBRTEMPLATE = (wFlags >> 15) & 0x0001;
+  pTRD->SBRTEMPLATE = !!((wFlags >> 15) & 0x0001);
 
   uint8_t cSBHUFFFS = 0;
   uint8_t cSBHUFFDS = 0;
   uint8_t cSBHUFFDT = 0;
   uint8_t cSBHUFFRDW = 0;
   uint8_t cSBHUFFRDH = 0;
   uint8_t cSBHUFFRDX = 0;
   uint8_t cSBHUFFRDY = 0;
   uint8_t cSBHUFFRSIZE = 0;
   if (pTRD->SBHUFF == 1) {
     if (m_pStream->readShortInteger(&wFlags) != 0)
       return JBIG2_ERROR_TOO_SHORT;
 
     cSBHUFFFS = wFlags & 0x0003;
     cSBHUFFDS = (wFlags >> 2) & 0x0003;
     cSBHUFFDT = (wFlags >> 4) & 0x0003;
     cSBHUFFRDW = (wFlags >> 6) & 0x0003;
     cSBHUFFRDH = (wFlags >> 8) & 0x0003;
     cSBHUFFRDX = (wFlags >> 10) & 0x0003;
     cSBHUFFRDY = (wFlags >> 12) & 0x0003;
     cSBHUFFRSIZE = (wFlags >> 14) & 0x0001;
   }
-  if (pTRD->SBREFINE == 1 && pTRD->SBRTEMPLATE == 0) {
+  if (pTRD->SBREFINE == 1 && !pTRD->SBRTEMPLATE) {
     for (int32_t i = 0; i < 4; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pTRD->SBRAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
   }
   if (m_pStream->readInteger(&pTRD->SBNUMINSTANCES) != 0)
     return JBIG2_ERROR_TOO_SHORT;
 
   for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
     if (!findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]))
@@ skipping 464 matching lines @@
 int32_t CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment* pSegment) {
   JBig2RegionInfo ri;
   uint8_t cFlags;
   if (parseRegionInfo(&ri) != JBIG2_SUCCESS ||
       m_pStream->read1Byte(&cFlags) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
   std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc);
   pGRRD->GRW = ri.width;
   pGRRD->GRH = ri.height;
-  pGRRD->GRTEMPLATE = cFlags & 0x01;
+  pGRRD->GRTEMPLATE = !!(cFlags & 0x01);
   pGRRD->TPGRON = (cFlags >> 1) & 0x01;
-  if (pGRRD->GRTEMPLATE == 0) {
+  if (!pGRRD->GRTEMPLATE) {
     for (int32_t i = 0; i < 4; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pGRRD->GRAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
   }
   CJBig2_Segment* pSeg = nullptr;
   if (pSegment->m_nReferred_to_segment_count > 0) {
     int32_t i;
     for (i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
       pSeg = findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[0]);
@@ skipping 203 matching lines @@
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
   FX_Free(LENCOUNT);
   FX_Free(FIRSTCODE);
 }