Make SkPicture/SkImageGenerator default to SkCodec

tests/PictureTest.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 "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorMatrixFilter.h"
 #include "SkColorPriv.h"
 #include "SkDashPathEffect.h"
 #include "SkData.h"
 #include "SkImageGenerator.h"
 #include "SkError.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkLayerInfo.h"
+#include "SkMD5.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
 #include "SkMiniRecorder.h"
 #include "SkRRect.h"
 #include "SkRandom.h"
 #include "SkRecord.h"
@@ skipping 834 matching lines @@
     ErrorContext* errorContext = static_cast<ErrorContext*>(context);
     errorContext->fErrors++;
     // This test only expects one error, and that is a kParseError. If there are others,
     // there is some unknown problem.
     REPORTER_ASSERT_MESSAGE(errorContext->fReporter, 1 == errorContext->fErrors,
                             "This threw more errors than expected.");
     REPORTER_ASSERT_MESSAGE(errorContext->fReporter, kParseError_SkError == error,
                             SkGetLastErrorString());
 }
 
-static void test_bitmap_with_encoded_data(skiatest::Reporter* reporter) {
+static void md5(const SkBitmap& bm, SkMD5::Digest* digest) {
+    SkAutoLockPixels autoLockPixels(bm);
+    SkASSERT(bm.getPixels());
+    SkMD5 md5;
+    size_t rowLen = bm.info().bytesPerPixel() * bm.width();
+    for (int y = 0; y < bm.height(); ++y) {
+        md5.update(static_cast<uint8_t*>(bm.getAddr(0, y)), rowLen);
+    }
+    md5.finish(*digest);
+}
+
+DEF_TEST(Picture_EncodedData, reporter) {
     // Create a bitmap that will be encoded.
     SkBitmap original;
     make_bm(&original, 100, 100, SK_ColorBLUE, true);
     SkDynamicMemoryWStream wStream;
     if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
         return;
     }
     SkAutoDataUnref data(wStream.copyToData());
 
     SkBitmap bm;
     bool installSuccess = SkDEPRECATED_InstallDiscardablePixelRef(data, &bm);
     REPORTER_ASSERT(reporter, installSuccess);
 
     // Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
     // Flattening original will follow the old path of performing an encode, while flattening bm
     // will use the already encoded data.
     SkAutoDataUnref picture1(serialized_picture_from_bitmap(original));
     SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
     REPORTER_ASSERT(reporter, picture1->equals(picture2));
+
     // Now test that a parse error was generated when trying to create a new SkPicture without
     // providing a function to decode the bitmap.
     ErrorContext context;
     context.fErrors = 0;
     context.fReporter = reporter;
     SkSetErrorCallback(assert_one_parse_error_cb, &context);
     SkMemoryStream pictureStream(picture1);
     SkClearLastError();
     SkAutoTUnref<SkPicture> pictureFromStream(SkPicture::CreateFromStream(&pictureStream, nullptr));
     REPORTER_ASSERT(reporter, pictureFromStream.get() != nullptr);
     SkClearLastError();
     SkSetErrorCallback(nullptr, nullptr);
+
+    // Test that using the version of CreateFromStream that just takes a stream also decodes the
+    // bitmap. Drawing this picture should look exactly like the original bitmap.
+    SkMD5::Digest referenceDigest;
+    md5(original, &referenceDigest);
+
+    SkBitmap dst;
+    dst.allocPixels(original.info());
+    dst.eraseColor(SK_ColorRED);
+    SkCanvas canvas(dst);
+
+    pictureStream.rewind();
+    pictureFromStream.reset(SkPicture::CreateFromStream(&pictureStream));
+    canvas.drawPicture(pictureFromStream.get());
+
+    SkMD5::Digest digest2;
+    md5(dst, &digest2);
+    REPORTER_ASSERT(reporter, referenceDigest == digest2);
 }
 
 static void test_clip_bound_opt(skiatest::Reporter* reporter) {
     // Test for crbug.com/229011
     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(4), SkIntToScalar(4),
                                     SkIntToScalar(2), SkIntToScalar(2));
     SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(7), SkIntToScalar(7),
                                     SkIntToScalar(1), SkIntToScalar(1));
     SkRect rect3 = SkRect::MakeXYWH(SkIntToScalar(6), SkIntToScalar(6),
                                     SkIntToScalar(1), SkIntToScalar(1));
@@ skipping 251 matching lines @@
     test_bad_bitmap();
 #endif
     test_unbalanced_save_restores(reporter);
     test_peephole();
 #if SK_SUPPORT_GPU
     test_gpu_veto(reporter);
 #endif
     test_has_text(reporter);
     test_images_are_found_by_willPlayBackBitmaps(reporter);
     test_analysis(reporter);
-    test_bitmap_with_encoded_data(reporter);
     test_clip_bound_opt(reporter);
     test_clip_expansion(reporter);
     test_hierarchical(reporter);
     test_gen_id(reporter);
     test_savelayer_extraction(reporter);
     test_cull_rect_reset(reporter);
 }
 
 static void draw_bitmaps(const SkBitmap bitmap, SkCanvas* canvas) {
     const SkPaint paint;
@@ skipping 190 matching lines @@
 
     SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
     SkAutoTUnref<SkPicture> deserializedPicture(SkPicture::CreateFromStream(rstream));
 
     REPORTER_ASSERT(r, SkToBool(deserializedPicture));
     REPORTER_ASSERT(r, deserializedPicture->cullRect().left() == 1);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().top() == 2);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().right() == 3);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().bottom() == 4);
 }