Fix and enable lint checks.

core/src/fxge/dib/fx_dib_composite.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/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_ge.h"
 #include "core/src/fxge/dib/dib_int.h"
 
@@ skipping 267 matching lines @@
   }
 }
 void _CompositeRow_Argb2Graya(uint8_t* dest_scan,
                               const uint8_t* src_scan,
                               int pixel_count,
                               int blend_type,
                               const uint8_t* clip_scan,
                               const uint8_t* src_alpha_scan,
                               uint8_t* dst_alpha_scan,
                               void* pIccTransform) {
-  ICodec_IccModule* pIccModule = NULL;
-  if (pIccTransform) {
+  ICodec_IccModule* pIccModule = nullptr;
+  if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  }
+
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int blended_color;
     if (src_alpha_scan) {
       for (int col = 0; col < pixel_count; col++) {
         uint8_t back_alpha = *dst_alpha_scan;
         if (back_alpha == 0) {
           int src_alpha = *src_alpha_scan++;
-          if (clip_scan) {
+          if (clip_scan)
             src_alpha = clip_scan[col] * src_alpha / 255;
-          }
+
           if (src_alpha) {
             if (pIccTransform) {
               pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
                                             1);
             } else {
               *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
             }
             *dst_alpha_scan = src_alpha;
           }
           dest_scan++;
           dst_alpha_scan++;
           src_scan += 3;
           continue;
         }
         uint8_t src_alpha = *src_alpha_scan++;
-        if (clip_scan) {
+        if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
-        }
+
         if (src_alpha == 0) {
           dest_scan++;
           dst_alpha_scan++;
           src_scan += 3;
           continue;
         }
         *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
         int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
         uint8_t gray;
         if (pIccTransform) {
           pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
         } else {
           gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
         }
         if (bNonseparableBlend) {
           blended_color =
               blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
         }
         gray = bNonseparableBlend ? blended_color
                                   : _BLEND(blend_type, *dest_scan, gray);
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 3;
       }
-    } else
+    } else {
       for (int col = 0; col < pixel_count; col++) {
         uint8_t back_alpha = *dst_alpha_scan;
         if (back_alpha == 0) {
           int src_alpha = src_scan[3];
-          if (clip_scan) {
+          if (clip_scan)
             src_alpha = clip_scan[col] * src_alpha / 255;
-          }
+
           if (src_alpha) {
             if (pIccTransform) {
               pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
                                             1);
             } else {
               *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
             }
             *dst_alpha_scan = src_alpha;
           }
           dest_scan++;
           dst_alpha_scan++;
           src_scan += 4;
           continue;
         }
         uint8_t src_alpha = src_scan[3];
-        if (clip_scan) {
+        if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
-        }
+
         if (src_alpha == 0) {
           dest_scan++;
           dst_alpha_scan++;
           src_scan += 4;
           continue;
         }
         *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
         int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
         uint8_t gray;
-        if (pIccTransform) {
+        if (pIccTransform)
           pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-        } else {
+        else
           gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-        }
+
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 4;
       }
+    }
     return;
   }
   if (src_alpha_scan) {
     for (int col = 0; col < pixel_count; col++) {
       uint8_t back_alpha = *dst_alpha_scan;
       if (back_alpha == 0) {
         int src_alpha = *src_alpha_scan++;
-        if (clip_scan) {
+        if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
-        }
+
         if (src_alpha) {
           if (pIccTransform) {
             pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
                                           1);
           } else {
             *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
           }
           *dst_alpha_scan = src_alpha;
         }
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 3;
         continue;
       }
       uint8_t src_alpha = *src_alpha_scan++;
-      if (clip_scan) {
+      if (clip_scan)
         src_alpha = clip_scan[col] * src_alpha / 255;
-      }
+
       if (src_alpha == 0) {
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 3;
         continue;
       }
       *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
       int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
       uint8_t gray;
-      if (pIccTransform) {
+      if (pIccTransform)
         pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-      } else {
+      else
         gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-      }
+
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
       dst_alpha_scan++;
       src_scan += 3;
     }
-  } else
+  } else {
     for (int col = 0; col < pixel_count; col++) {
       uint8_t back_alpha = *dst_alpha_scan;
       if (back_alpha == 0) {
         int src_alpha = src_scan[3];
-        if (clip_scan) {
+        if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
-        }
+
         if (src_alpha) {
           if (pIccTransform) {
             pIccModule->TranslateScanline(pIccTransform, dest_scan, src_scan,
                                           1);
           } else {
             *dest_scan = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
           }
           *dst_alpha_scan = src_alpha;
         }
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 4;
         continue;
       }
       uint8_t src_alpha = src_scan[3];
-      if (clip_scan) {
+      if (clip_scan)
         src_alpha = clip_scan[col] * src_alpha / 255;
-      }
+
       if (src_alpha == 0) {
         dest_scan++;
         dst_alpha_scan++;
         src_scan += 4;
         continue;
       }
       *dst_alpha_scan = FXDIB_ALPHA_UNION(back_alpha, src_alpha);
       int alpha_ratio = src_alpha * 255 / (*dst_alpha_scan);
       uint8_t gray;
-      if (pIccTransform) {
+      if (pIccTransform)
         pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-      } else {
+      else
         gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-      }
+
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, alpha_ratio);
       dest_scan++;
       dst_alpha_scan++;
       src_scan += 4;
     }
+  }
 }
+
 inline void _CompositeRow_Argb2Gray(uint8_t* dest_scan,
                                     const uint8_t* src_scan,
                                     int pixel_count,
                                     int blend_type,
                                     const uint8_t* clip_scan,
                                     const uint8_t* src_alpha_scan,
                                     void* pIccTransform) {
   ICodec_IccModule* pIccModule = NULL;
   uint8_t gray;
-  if (pIccTransform) {
+  if (pIccTransform)
     pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
-  }
+
   if (blend_type) {
     FX_BOOL bNonseparableBlend = blend_type >= FXDIB_BLEND_NONSEPARABLE;
     int blended_color;
     if (src_alpha_scan) {
       for (int col = 0; col < pixel_count; col++) {
         int src_alpha = *src_alpha_scan++;
-        if (clip_scan) {
+        if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
-        }
+
         if (src_alpha) {
-          if (pIccTransform) {
+          if (pIccTransform)
             pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-          } else {
+          else
             gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-          }
+
           if (bNonseparableBlend) {
             blended_color =
                 blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
           }
           gray = bNonseparableBlend ? blended_color
                                     : _BLEND(blend_type, *dest_scan, gray);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         }
         dest_scan++;
         src_scan += 3;
       }
-    } else
+    } else {
       for (int col = 0; col < pixel_count; col++) {
         int src_alpha = src_scan[3];
-        if (clip_scan) {
+        if (clip_scan)
           src_alpha = clip_scan[col] * src_alpha / 255;
-        }
+
         if (src_alpha) {
-          if (pIccTransform) {
+          if (pIccTransform)
             pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-          } else {
+          else
             gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-          }
+
           if (bNonseparableBlend) {
             blended_color =
                 blend_type == FXDIB_BLEND_LUMINOSITY ? gray : *dest_scan;
           }
           gray = bNonseparableBlend ? blended_color
                                     : _BLEND(blend_type, *dest_scan, gray);
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
         }
         dest_scan++;
         src_scan += 4;
       }
+    }
     return;
   }
   if (src_alpha_scan) {
     for (int col = 0; col < pixel_count; col++) {
       int src_alpha = *src_alpha_scan++;
-      if (clip_scan) {
+      if (clip_scan)
         src_alpha = clip_scan[col] * src_alpha / 255;
-      }
+
       if (src_alpha) {
-        if (pIccTransform) {
+        if (pIccTransform)
           pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-        } else {
+        else
           gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-        }
+
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
       }
       dest_scan++;
       src_scan += 3;
     }
-  } else
+  } else {
     for (int col = 0; col < pixel_count; col++) {
       int src_alpha = src_scan[3];
-      if (clip_scan) {
+      if (clip_scan)
         src_alpha = clip_scan[col] * src_alpha / 255;
-      }
+
       if (src_alpha) {
-        if (pIccTransform) {
+        if (pIccTransform)
           pIccModule->TranslateScanline(pIccTransform, &gray, src_scan, 1);
-        } else {
+        else
           gray = FXRGB2GRAY(src_scan[2], src_scan[1], *src_scan);
-        }
+
         *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
       }
       dest_scan++;
       src_scan += 4;
     }
+  }
 }
+
 inline void _CompositeRow_Rgb2Gray(uint8_t* dest_scan,
                                    const uint8_t* src_scan,
                                    int src_Bpp,
                                    int pixel_count,
                                    int blend_type,
                                    const uint8_t* clip_scan,
                                    void* pIccTransform) {
   ICodec_IccModule* pIccModule = NULL;
   uint8_t gray;
   if (pIccTransform) {
@@ skipping 1730 matching lines @@
       dest_scan[3] = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
       dest_scan++;
       dest_scan++;
     }
-  } else
+  } else {
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
       int src_r = FXARGB_R(argb);
       int src_g = FXARGB_G(argb);
       int src_b = FXARGB_B(argb);
       if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = src_b;
         *dest_scan++ = src_g;
         *dest_scan++ = src_r;
         *dest_scan++ = 255;
@@ skipping 13 matching lines @@
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
       dest_scan++;
       dest_scan++;
       src_scan++;
     }
+  }
 }
+
 void _CompositeRow_8bppRgb2Rgba_NoBlend(uint8_t* dest_scan,
                                         const uint8_t* src_scan,
                                         int width,
                                         FX_DWORD* pPalette,
                                         const uint8_t* clip_scan,
                                         uint8_t* dest_alpha_scan,
                                         const uint8_t* src_alpha_scan) {
   if (src_alpha_scan) {
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
@@ skipping 30 matching lines @@
           back_alpha + src_alpha - back_alpha * src_alpha / 255;
       *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
       dest_scan++;
     }
-  } else
+  } else {
     for (int col = 0; col < width; col++) {
       FX_ARGB argb = pPalette[*src_scan];
       int src_r = FXARGB_R(argb);
       int src_g = FXARGB_G(argb);
       int src_b = FXARGB_B(argb);
       if (!clip_scan || clip_scan[col] == 255) {
         *dest_scan++ = src_b;
         *dest_scan++ = src_g;
         *dest_scan++ = src_r;
         *dest_alpha_scan++ = 255;
@@ skipping 13 matching lines @@
       *dest_alpha_scan++ = dest_alpha;
       int alpha_ratio = src_alpha * 255 / dest_alpha;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_b, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_g, alpha_ratio);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, src_r, alpha_ratio);
       dest_scan++;
       src_scan++;
     }
+  }
 }
+
 inline void _CompositeRow_1bppRgb2Argb_NoBlend(uint8_t* dest_scan,
                                                const uint8_t* src_scan,
                                                int src_left,
                                                int width,
                                                FX_DWORD* pPalette,
                                                const uint8_t* clip_scan) {
   int reset_r, reset_g, reset_b;
   int set_r, set_g, set_b;
   reset_r = FXARGB_R(pPalette[0]);
   reset_g = FXARGB_G(pPalette[0]);
@@ skipping 1651 matching lines @@
         pDestPalette = (FX_DWORD*)gray_pal;
         if (isSrcCmyk) {
           for (int i = 0; i < pal_count; i++) {
             FX_CMYK cmyk = pSrcPalette[i];
             uint8_t r, g, b;
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
                                FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r,
                                g, b);
             *gray_pal++ = FXRGB2GRAY(r, g, b);
           }
-        } else
+        } else {
           for (int i = 0; i < pal_count; i++) {
             FX_ARGB argb = pSrcPalette[i];
             *gray_pal++ =
                 FXRGB2GRAY(FXARGB_R(argb), FXARGB_G(argb), FXARGB_B(argb));
           }
+        }
       } else {
         int palsize = 1 << (src_format & 0xff);
         pDestPalette = FX_Alloc(FX_DWORD, palsize);
         if (isDstCmyk == isSrcCmyk) {
           FXSYS_memcpy(pDestPalette, pSrcPalette, palsize * sizeof(FX_DWORD));
         } else {
           for (int i = 0; i < palsize; i++) {
             FX_CMYK cmyk = pSrcPalette[i];
             uint8_t r, g, b;
             AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
@@ skipping 440 matching lines @@
                                 clip_scan);
   } else if ((m_DestFormat & 0xff) == 8) {
     if (m_DestFormat & 0x0200) {
       _CompositeRow_ByteMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                    width, clip_scan, dst_extra_alpha);
     } else {
       _CompositeRow_ByteMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                   width, clip_scan);
     }
   } else if (m_bRgbByteOrder) {
-    if (m_DestFormat == FXDIB_Argb)
+    if (m_DestFormat == FXDIB_Argb) {
       _CompositeRow_ByteMask2Argb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           width, m_BlendType, clip_scan);
-    else
+    } else {
       _CompositeRow_ByteMask2Rgb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
+    }
     return;
-  } else if (m_DestFormat == FXDIB_Argb)
+  } else if (m_DestFormat == FXDIB_Argb) {
     _CompositeRow_ByteMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                 m_MaskGreen, m_MaskBlue, width, m_BlendType,
                                 clip_scan);
-  else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32)
+  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
     _CompositeRow_ByteMask2Rgb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                m_MaskGreen, m_MaskBlue, width, m_BlendType,
                                (m_DestFormat & 0xff) >> 3, clip_scan);
-  else if (m_DestFormat == FXDIB_Rgba)
+  } else if (m_DestFormat == FXDIB_Rgba) {
     _CompositeRow_ByteMask2Rgba(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                 m_MaskGreen, m_MaskBlue, width, m_BlendType,
                                 clip_scan, dst_extra_alpha);
+  }
 }
 void CFX_ScanlineCompositor::CompositeBitMaskLine(uint8_t* dest_scan,
                                                   const uint8_t* src_scan,
                                                   int src_left,
                                                   int width,
                                                   const uint8_t* clip_scan,
                                                   uint8_t* dst_extra_alpha) {
   if (m_DestFormat == FXDIB_8bppMask) {
     _CompositeRow_BitMask2Mask(dest_scan, src_scan, m_MaskAlpha, src_left,
                                width, clip_scan);
   } else if ((m_DestFormat & 0xff) == 8) {
-    if (m_DestFormat & 0x0200)
+    if (m_DestFormat & 0x0200) {
       _CompositeRow_BitMask2Graya(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                   src_left, width, clip_scan, dst_extra_alpha);
-    else {
+    } else {
       _CompositeRow_BitMask2Gray(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                  src_left, width, clip_scan);
     }
   } else if (m_bRgbByteOrder) {
-    if (m_DestFormat == FXDIB_Argb)
+    if (m_DestFormat == FXDIB_Argb) {
       _CompositeRow_BitMask2Argb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           src_left, width, m_BlendType, clip_scan);
-    else
+    } else {
       _CompositeRow_BitMask2Rgb_RgbByteOrder(
           dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
           src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
+    }
     return;
-  } else if (m_DestFormat == FXDIB_Argb)
+  } else if (m_DestFormat == FXDIB_Argb) {
     _CompositeRow_BitMask2Argb(dest_scan, src_scan, m_MaskAlpha, m_MaskRed,
                                m_MaskGreen, m_MaskBlue, src_left, width,
                                m_BlendType, clip_scan);
-  else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32)
+  } else if (m_DestFormat == FXDIB_Rgb || m_DestFormat == FXDIB_Rgb32) {
     _CompositeRow_BitMask2Rgb(
         dest_scan, src_scan, m_MaskAlpha, m_MaskRed, m_MaskGreen, m_MaskBlue,
         src_left, width, m_BlendType, (m_DestFormat & 0xff) >> 3, clip_scan);
+  }
 }
+
 FX_BOOL CFX_DIBitmap::CompositeBitmap(int dest_left,
                                       int dest_top,
                                       int width,
                                       int height,
                                       const CFX_DIBSource* pSrcBitmap,
                                       int src_left,
                                       int src_top,
                                       int blend_type,
                                       const CFX_ClipRgn* pClipRgn,
                                       FX_BOOL bRgbByteOrder,
@@ skipping 174 matching lines @@
         }
       }
       if (IsCmykImage()) {
         gray = ~gray;
       }
     }
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan = m_pBuffer + row * m_Pitch + rect.left;
       if (src_alpha == 255) {
         FXSYS_memset(dest_scan, gray, width);
-      } else
+      } else {
         for (int col = 0; col < width; col++) {
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, gray, src_alpha);
           dest_scan++;
         }
+      }
     }
     return TRUE;
   }
   if (m_bpp == 1) {
     ASSERT(!IsCmykImage() && (uint8_t)(alpha_flag >> 8) == 0);
     int left_shift = rect.left % 8;
     int right_shift = rect.right % 8;
     int width = rect.right / 8 - rect.left / 8;
     int index = 0;
     if (m_pPalette) {
@@ skipping 31 matching lines @@
   }
   ASSERT(m_bpp >= 24);
   if (m_bpp < 24) {
     return FALSE;
   }
   if (pIccTransform && CFX_GEModule::Get()->GetCodecModule()) {
     ICodec_IccModule* pIccModule =
         CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
     pIccModule->TranslateScanline(pIccTransform, color_p, color_p, 1);
   } else {
-    if (alpha_flag >> 8 && !IsCmykImage())
+    if (alpha_flag >> 8 && !IsCmykImage()) {
       AdobeCMYK_to_sRGB1(FXSYS_GetCValue(color), FXSYS_GetMValue(color),
                          FXSYS_GetYValue(color), FXSYS_GetKValue(color),
                          color_p[2], color_p[1], color_p[0]);
-    else if (!(alpha_flag >> 8) && IsCmykImage()) {
+    } else if (!(alpha_flag >> 8) && IsCmykImage()) {
       return FALSE;
     }
   }
   if (!IsCmykImage()) {
     color_p[3] = (uint8_t)src_alpha;
   }
   int Bpp = m_bpp / 8;
   FX_BOOL bAlpha = HasAlpha();
   bool bArgb = GetFormat() == FXDIB_Argb;
   if (src_alpha == 255) {
@@ skipping 272 matching lines @@
   }
   src_alpha_scan = m_pScanlineAlphaV;
   dest_alpha_scan = dest_alpha_buf;
   if (dest_alpha_scan) {
     for (i = 0; i < m_DestHeight; i++) {
       *dest_alpha_scan = *src_alpha_scan++;
       dest_alpha_scan += y_alpha_step;
     }
   }
 }