Fix all the code which has duplicate variable declarations

core/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/fxcodec/include/fx_codec.h"
 #include "core/fxge/dib/dib_int.h"
 #include "core/fxge/include/fx_ge.h"
 
@@ skipping 2494 matching lines @@
     }
     if (src_alpha == 0) {
       dest_scan += 4;
       continue;
     }
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     dest_scan[3] = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
       dest_scan++;
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
       dest_scan++;
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
     } else if (blend_type) {
       int blended = Blend(blend_type, *dest_scan, src_b);
@@ skipping 46 matching lines @@
     if (src_alpha == 0) {
       dest_scan += 3;
       dest_alpha_scan++;
       continue;
     }
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     *dest_alpha_scan++ = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
       dest_scan++;
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
       dest_scan++;
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
       dest_scan++;
     } else if (blend_type) {
@@ skipping 36 matching lines @@
       src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
     } else {
       src_alpha = mask_alpha * src_scan[col] / 255;
     }
     if (src_alpha == 0) {
       dest_scan += Bpp;
       continue;
     }
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
     } else if (blend_type) {
       int blended = Blend(blend_type, *dest_scan, src_b);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
       dest_scan++;
       blended = Blend(blend_type, *dest_scan, src_g);
@@ skipping 122 matching lines @@
     if (back_alpha == 0) {
       FXARGB_SETDIB(dest_scan, FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
       dest_scan += 4;
       continue;
     }
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     dest_scan[3] = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], alpha_ratio);
       dest_scan++;
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], alpha_ratio);
       dest_scan++;
       *dest_scan =
           FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], alpha_ratio);
     } else if (blend_type) {
       int blended = Blend(blend_type, *dest_scan, src_b);
@@ skipping 50 matching lines @@
       src_alpha = mask_alpha * clip_scan[col] / 255;
     } else {
       src_alpha = mask_alpha;
     }
     if (src_alpha == 0) {
       dest_scan += Bpp;
       continue;
     }
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      RGB_Blend(blend_type, src_scan, dest_scan, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      RGB_Blend(blend_type, scan, dest_scan, blended_colors);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[0], src_alpha);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[1], src_alpha);
       dest_scan++;
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended_colors[2], src_alpha);
     } else if (blend_type) {
       int blended = Blend(blend_type, *dest_scan, src_b);
       *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, blended, src_alpha);
       dest_scan++;
       blended = Blend(blend_type, *dest_scan, src_g);
@@ skipping 693 matching lines @@
     }
     if (src_alpha == 0) {
       dest_scan += 4;
       continue;
     }
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     dest_scan[3] = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      uint8_t dest_scan_o[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
       dest_scan[1] =
           FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
       dest_scan[0] =
           FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
     } else if (blend_type) {
       int blended = Blend(blend_type, dest_scan[2], src_b);
       blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
       dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio);
@@ skipping 28 matching lines @@
       src_alpha = mask_alpha * clip_scan[col] * src_scan[col] / 255 / 255;
     } else {
       src_alpha = mask_alpha * src_scan[col] / 255;
     }
     if (src_alpha == 0) {
       dest_scan += Bpp;
       continue;
     }
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      uint8_t dest_scan_o[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
       dest_scan[1] =
           FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
       dest_scan[0] =
           FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
     } else if (blend_type) {
       int blended = Blend(blend_type, dest_scan[2], src_b);
       dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, src_alpha);
       blended = Blend(blend_type, dest_scan[1], src_g);
@@ skipping 45 matching lines @@
       FXARGB_SETRGBORDERDIB(dest_scan,
                             FXARGB_MAKE(src_alpha, src_r, src_g, src_b));
       dest_scan += 4;
       continue;
     }
     uint8_t dest_alpha = back_alpha + src_alpha - back_alpha * src_alpha / 255;
     dest_scan[3] = dest_alpha;
     int alpha_ratio = src_alpha * 255 / dest_alpha;
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      uint8_t dest_scan_o[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], alpha_ratio);
       dest_scan[1] =
           FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], alpha_ratio);
       dest_scan[0] =
           FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], alpha_ratio);
     } else if (blend_type) {
       int blended = Blend(blend_type, dest_scan[2], src_b);
       blended = FXDIB_ALPHA_MERGE(src_b, blended, back_alpha);
       dest_scan[2] = FXDIB_ALPHA_MERGE(dest_scan[2], blended, alpha_ratio);
@@ skipping 44 matching lines @@
       src_alpha = mask_alpha * clip_scan[col] / 255;
     } else {
       src_alpha = mask_alpha;
     }
     if (src_alpha == 0) {
       dest_scan += Bpp;
       continue;
     }
     if (blend_type >= FXDIB_BLEND_NONSEPARABLE) {
       int blended_colors[3];
-      uint8_t src_scan[3];
-      uint8_t dest_scan_o[3];
-      src_scan[0] = src_b;
-      src_scan[1] = src_g;
-      src_scan[2] = src_r;
-      dest_scan_o[0] = dest_scan[2];
-      dest_scan_o[1] = dest_scan[1];
-      dest_scan_o[2] = dest_scan[0];
-      RGB_Blend(blend_type, src_scan, dest_scan_o, blended_colors);
+      uint8_t scan[3] = {static_cast<uint8_t>(src_b),
+                         static_cast<uint8_t>(src_g),
+                         static_cast<uint8_t>(src_r)};
+      uint8_t dest_scan_o[3] = {dest_scan[2], dest_scan[1], dest_scan[0]};
+      RGB_Blend(blend_type, scan, dest_scan_o, blended_colors);
       dest_scan[2] =
           FXDIB_ALPHA_MERGE(dest_scan[2], blended_colors[0], src_alpha);
       dest_scan[1] =
           FXDIB_ALPHA_MERGE(dest_scan[1], blended_colors[1], src_alpha);
       dest_scan[0] =
           FXDIB_ALPHA_MERGE(dest_scan[0], blended_colors[2], src_alpha);
     } else if (blend_type) {
       int back_color = dest_scan[2];
       int blended = Blend(blend_type, back_color, src_b);
       dest_scan[2] = FXDIB_ALPHA_MERGE(back_color, blended, src_alpha);
@@ skipping 893 matching lines @@
           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 new_width = rect.right / 8 - rect.left / 8;
     int index = 0;
     if (m_pPalette) {
       for (int i = 0; i < 2; i++) {
         if (m_pPalette[i] == color) {
           index = i;
         }
       }
     } else {
       index = ((uint8_t)color == 0xff) ? 1 : 0;
     }
     for (int row = rect.top; row < rect.bottom; row++) {
       uint8_t* dest_scan_top = (uint8_t*)GetScanline(row) + rect.left / 8;
       uint8_t* dest_scan_top_r = (uint8_t*)GetScanline(row) + rect.right / 8;
       uint8_t left_flag = *dest_scan_top & (255 << (8 - left_shift));
       uint8_t right_flag = *dest_scan_top_r & (255 >> right_shift);
-      if (width) {
-        FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, width - 1);
+      if (new_width) {
+        FXSYS_memset(dest_scan_top + 1, index ? 255 : 0, new_width - 1);
         if (!index) {
           *dest_scan_top &= left_flag;
           *dest_scan_top_r &= right_flag;
         } else {
           *dest_scan_top |= ~left_flag;
           *dest_scan_top_r |= ~right_flag;
         }
       } else {
         if (!index) {
           *dest_scan_top &= left_flag | right_flag;
@@ skipping 309 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;
     }
   }
 }