make an image from a mutable bitmap

tests/ImageTest.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 <functional>
 #include <initializer_list>
 #include <vector>
 #include "DMGpuSupport.h"
 
 #include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkImage_Base.h"
+#include "SkImagePriv.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPixelSerializer.h"
 #include "SkRRect.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
@@ skipping 157 matching lines @@
 DEF_TEST(ImageEncode, reporter) {
     test_encode(reporter, create_image().get());
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageEncode_Gpu, reporter, ctxInfo) {
     test_encode(reporter, create_gpu_image(ctxInfo.grContext()).get());
 }
 #endif
 
+DEF_TEST(Image_MakeFromRasterBitmap, reporter) {
+    const struct {
+        ForceCopyMode fMode;
+        bool          fExpectSameAsMutable;
+        bool          fExpectSameAsImmutable;
+    } recs[] = {
+        { kNo_ForceCopyMode,    false,  true },
+        { kYes_ForceCopyMode,   false,  false },
+        { kNever_ForceCopyMode, true,   true },
+    };
+    for (auto rec : recs) {
+        SkPixmap pm;
+        SkBitmap bm;
+        bm.allocN32Pixels(100, 100);
+
+        auto img = SkMakeImageFromRasterBitmap(bm, rec.fMode);
+        REPORTER_ASSERT(reporter, img->peekPixels(&pm));
+        const bool sameMutable = pm.addr32(0, 0) == bm.getAddr32(0, 0);
+        REPORTER_ASSERT(reporter, rec.fExpectSameAsMutable == sameMutable);
+
+        bm.notifyPixelsChanged();   // force a new generation ID
+
+        bm.setImmutable();
+        img = SkMakeImageFromRasterBitmap(bm, rec.fMode);
+        REPORTER_ASSERT(reporter, img->peekPixels(&pm));
+        const bool sameImmutable = pm.addr32(0, 0) == bm.getAddr32(0, 0);
+        REPORTER_ASSERT(reporter, rec.fExpectSameAsImmutable == sameImmutable);
+    }
+}
+
 namespace {
 
 const char* kSerializedData = "serialized";
 
 class MockSerializer : public SkPixelSerializer {
 public:
     MockSerializer(SkData* (*func)()) : fFunc(func), fDidEncode(false) { }
 
     bool didEncode() const { return fDidEncode; }
 
@@ skipping 778 matching lines @@
     SkBitmap bm1;
     bm1.allocPixels(SkImageInfo::MakeN32(256, 256, kUnpremul_SkAlphaType));
     bm0.readPixels(bm1.info(), bm1.getPixels(), bm1.rowBytes(), 0, 0);
 
     SkBitmap bm2;
     bm2.allocPixels(SkImageInfo::MakeN32(256, 256, kPremul_SkAlphaType));
     bm1.readPixels(bm2.info(), bm2.getPixels(), bm2.rowBytes(), 0, 0);
 
     REPORTER_ASSERT(reporter, equal(bm0, bm2));
 }