Support for larger than "signed 32b limit" sized bitmaps in BGRAConvolve2D.

src/core/SkConvolver.cpp

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "SkConvolver.h"
 #include "SkSize.h"
 #include "SkTypes.h"
 
 namespace {
 
@@ skipping 387 matching lines @@
                                               &filterOffset, &filterLength);
 
         // Generate output rows until we have enough to run the current filter.
         while (nextXRow < filterOffset + filterLength) {
             if (convolveProcs.fConvolve4RowsHorizontally &&
                 nextXRow + 3 < lastFilterOffset + lastFilterLength -
                 avoidSimdRows) {
                 const unsigned char* src[4];
                 unsigned char* outRow[4];
                 for (int i = 0; i < 4; ++i) {
-                    src[i] = &sourceData[(nextXRow + i) * sourceByteRowStride];
+                    src[i] = &sourceData[(uint64_t)(nextXRow + i) * sourceByteRowStride];
                     outRow[i] = rowBuffer.advanceRow();
                 }
                 convolveProcs.fConvolve4RowsHorizontally(src, filterX, outRow);
                 nextXRow += 4;
             } else {
                 // Check if we need to avoid SSE2 for this row.
                 if (convolveProcs.fConvolveHorizontally &&
                     nextXRow < lastFilterOffset + lastFilterLength -
                     avoidSimdRows) {
                     convolveProcs.fConvolveHorizontally(
-                        &sourceData[nextXRow * sourceByteRowStride],
+                        &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                         filterX, rowBuffer.advanceRow(), sourceHasAlpha);
                 } else {
                     if (sourceHasAlpha) {
                         ConvolveHorizontally<true>(
-                            &sourceData[nextXRow * sourceByteRowStride],
+                            &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                             filterX, rowBuffer.advanceRow());
                     } else {
                         ConvolveHorizontally<false>(
-                            &sourceData[nextXRow * sourceByteRowStride],
+                            &sourceData[(uint64_t)nextXRow * sourceByteRowStride],
                             filterX, rowBuffer.advanceRow());
                     }
                 }
                 nextXRow++;
             }
         }
 
         // Compute where in the output image this row of final data will go.
         unsigned char* curOutputRow = &output[outY * outputByteRowStride];
 
@@ skipping 13 matching lines @@
                                                filterX.numValues(), curOutputRow,
                                                sourceHasAlpha);
         } else {
             ConvolveVertically(filterValues, filterLength,
                                firstRowForFilter,
                                filterX.numValues(), curOutputRow,
                                sourceHasAlpha);
         }
     }
 }