Silence ASAN int32 overflow warning

src/effects/gradients/SkLinearGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "SkLinearGradient.h"
 
@@ skipping 594 matching lines @@
     Sk4f dither1(dither[1]);
     const Rec* rec = fRecs.begin();
 
     const Sk4f dx4 = Sk4f(dx);
     SkDEBUGCODE(SkPMColor* endDstC = dstC + count;)
 
     if (dx_is_pos) {
         if (fx < 0) {
             // count is guaranteed to be positive, but the first arg may overflow int32 after
             // increment => casting to uint32 ensures correct clamping.
-            int n = SkTMin<uint32_t>(SkFloatToIntFloor(-fx * invDx) + 1, count);
+            int n = SkTMin<uint32_t>(static_cast<uint32_t>(SkFloatToIntFloor(-fx * invDx)) + 1,

[mtklein, 2016/05/27 05:17:03]

See if I'm following this correctly?

  1) We're a safe int32_t after SkFloatToIntFloor(...), with a max of
0x7fffffff.

  2) Then we cast it to uint32_t and add 1.  This is a safe uint32_t but a
possibly wrapped int32_t (0x8000000).

  3) Then we min it with count as uint32_t.  Is that what makes this safe?  We
know count is in [0, 0x7ffffff] ?

  4) That uint32_t in [0, 0x7fffffff] is finally cast back to a safe int32_t.

+                                     count);
             SkASSERT(n > 0);
             fill<apply_alpha>(dstC, n, rec[0].fColor);
             count -= n;
             dstC += n;
             fx += n * dx;
             SkASSERT(0 == count || fx >= 0);
             if (n & 1) {
                 SkTSwap(dither0, dither1);
             }
         }
     } else { // dx < 0
         if (fx > 1) {
             // count is guaranteed to be positive, but the first arg may overflow int32 after
             // increment => casting to uint32 ensures correct clamping.
-            int n = SkTMin<uint32_t>(SkFloatToIntFloor((1 - fx) * invDx) + 1, count);
+            int n = SkTMin<uint32_t>(static_cast<uint32_t>(SkFloatToIntFloor((1 - fx) * invDx)) + 1,
+                                     count);
             SkASSERT(n > 0);
             fill<apply_alpha>(dstC, n, rec[fRecs.count() - 1].fColor);
             count -= n;
             dstC += n;
             fx += n * dx;
             SkASSERT(0 == count || fx <= 1);
             if (n & 1) {
                 SkTSwap(dither0, dither1);
             }
         }
@@ skipping 111 matching lines @@
             this->shade4_dx_clamp<false, true>(dstC, count, fx, dx, invDx, dither);
         }
     } else {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
         }
     }
 }