flags and hacks to get MSAN bot going

src/codec/SkJpegCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
+#include "SkMSAN.h"
 #include "SkJpegCodec.h"
 #include "SkJpegDecoderMgr.h"
 #include "SkJpegUtility_codec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
 
 // stdio is needed for libjpeg-turbo
@@ skipping 189 matching lines @@
                 // much faster than decoding to color and then converting
                 fDecoderMgr->dinfo()->out_color_space = JCS_GRAYSCALE;
             }
             return true;
         default:
             return false;
     }
 }
 
 /*
- * Checks if we can natively scale to the requested dimensions and natively scales the 
+ * Checks if we can natively scale to the requested dimensions and natively scales the
  * dimensions if possible
  */
 bool SkJpegCodec::onDimensionsSupported(const SkISize& size) {
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFalse("onDimensionsSupported/setjmp");
     }
 
     const unsigned int dstWidth = size.width();
     const unsigned int dstHeight = size.height();
 
@@ skipping 72 matching lines @@
         // write data to storage row, then sample using swizzler
         dstRow = fSrcRow;
     } else {
         // write data directly to dst
         dstRow = (JSAMPLE*) dst;
     }
 
     for (uint32_t y = 0; y < dstHeight; y++) {
         // Read rows of the image
         uint32_t lines = jpeg_read_scanlines(dinfo, &dstRow, 1);
+        sk_msan_mark_initialized(dstRow, dstRow + dstRowBytes, "skbug.com/4550");
 
         // If we cannot read enough rows, assume the input is incomplete
         if (lines != 1) {
             *rowsDecoded = y;
 
             return fDecoderMgr->returnFailure("Incomplete image data", kIncompleteInput);
         }
 
         if (fSwizzler) {
             // use swizzler to sample row
@@ skipping 71 matching lines @@
 
     // We will need a swizzler if we are performing a subset decode or
     // converting from CMYK.
     if (options.fSubset || JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
         this->initializeSwizzler(dstInfo, options);
     }
 
     return kSuccess;
 }
 
-int SkJpegCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
+int SkJpegCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
     }
     // Read rows one at a time
     JSAMPLE* dstRow;
+    size_t srcRowBytes = get_row_bytes(fDecoderMgr->dinfo());
     if (fSwizzler) {
         // write data to storage row, then sample using swizzler
         dstRow = fSrcRow;
     } else {
         // write data directly to dst
+        SkASSERT(count == 1 || dstRowBytes >= srcRowBytes);
         dstRow = (JSAMPLE*) dst;
     }
 
     for (int y = 0; y < count; y++) {
         // Read row of the image
         uint32_t rowsDecoded = jpeg_read_scanlines(fDecoderMgr->dinfo(), &dstRow, 1);
+        sk_msan_mark_initialized(dstRow, dstRow + srcRowBytes, "skbug.com/4550");
         if (rowsDecoded != 1) {
             fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
             return y;
         }
 
         if (fSwizzler) {
             // use swizzler to sample row
             fSwizzler->swizzle(dst, dstRow);
-            dst = SkTAddOffset<JSAMPLE>(dst, rowBytes);
+            dst = SkTAddOffset<JSAMPLE>(dst, dstRowBytes);
         } else {
-            dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
+            dstRow = SkTAddOffset<JSAMPLE>(dstRow, dstRowBytes);
         }
     }
     return count;
 }
 
 #ifndef TURBO_HAS_SKIP
 // TODO (msarett): Avoid reallocating the memory buffer on each call to skip.
 static uint32_t jpeg_skip_scanlines(jpeg_decompress_struct* dinfo, int count) {
     SkAutoTMalloc<uint8_t> storage(get_row_bytes(dinfo));
     uint8_t* storagePtr = storage.get();
@@ skipping 200 matching lines @@
 
         JDIMENSION linesRead = jpeg_read_raw_data(dinfo, yuv, numRowsPerBlock);
         if (linesRead < remainingRows) {
             // FIXME: Handle incomplete YUV decodes without signalling an error.
             return kInvalidInput;
         }
     }
 
     return kSuccess;
 }