Fix uninitialized memory on kIndex8 divisor tests in Gold

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkAndroidCodec.h"
@@ skipping 666 matching lines @@
             return "";
         }
         case kDivisor_Mode: {
             const int width = codec->getInfo().width();
             const int height = codec->getInfo().height();
             const int divisor = 2;
             if (width < divisor || height < divisor) {
                 return Error::Nonfatal("Divisor is larger than image dimension.\n");
             }
 
-            // Rounding the size of the subsets may leave some pixels uninitialized on the bottom
-            // and right edges of the bitmap.
-            bitmap.eraseColor(0);
+            // Keep track of the final decoded dimensions.
+            int finalScaledWidth = 0;
+            int finalScaledHeight = 0;
             for (int x = 0; x < divisor; x++) {
                 for (int y = 0; y < divisor; y++) {
                     // Calculate the subset dimensions
                     int subsetWidth = width / divisor;
                     int subsetHeight = height / divisor;
                     const int left = x * subsetWidth;
                     const int top = y * subsetHeight;
 
                     // Increase the size of the last subset in each row or column, when the
                     // divisor does not divide evenly into the image dimensions
                     subsetWidth += (x + 1 == divisor) ? (width % divisor) : 0;
                     subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
                     SkIRect subset = SkIRect::MakeXYWH(left, top, subsetWidth, subsetHeight);
                     if (!codec->getSupportedSubset(&subset)) {
                         return "Could not get supported subset to decode.\n";
                     }
                     options.fSubset = &subset;
-                    void* pixels = bitmap.getAddr(subset.left() / fSampleSize,
-                            subset.top() / fSampleSize);
+                    const int scaledWidthOffset = subset.left() / fSampleSize;
+                    const int scaledHeightOffset = subset.top() / fSampleSize;
+                    void* pixels = bitmap.getAddr(scaledWidthOffset, scaledHeightOffset);
                     SkISize scaledSubsetSize = codec->getSampledSubsetDimensions(fSampleSize,
                             subset);
                     SkImageInfo subsetDecodeInfo = decodeInfo.makeWH(scaledSubsetSize.width(),
                             scaledSubsetSize.height());
 
+                    if (x + 1 == divisor && y + 1 == divisor) {
+                        finalScaledWidth = scaledWidthOffset + scaledSubsetSize.width();
+                        finalScaledHeight = scaledHeightOffset + scaledSubsetSize.height();
+                    }
+
                     switch (codec->getAndroidPixels(subsetDecodeInfo, pixels, bitmap.rowBytes(),
                             &options)) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         case SkCodec::kInvalidConversion:
                             return Error::Nonfatal("Cannot convert to requested color type.\n");
                         default:
                             return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
                     }
                 }
             }
-            canvas->drawBitmap(bitmap, 0, 0);
+
+            SkRect rect = SkRect::MakeXYWH(0, 0, (SkScalar) finalScaledWidth,
+                    (SkScalar) finalScaledHeight);
+            canvas->drawBitmapRect(bitmap, rect, rect, nullptr);
             return "";
         }
         default:
             SkASSERT(false);
             return "Error: Should not be reached.\n";
     }
 }
 
 SkISize AndroidCodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
@@ skipping 618 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM