Revert[2] of add ImageShader, sharing code with its Bitmap cousin

tests/ImageNewShaderTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #endif
 #include "SkCanvas.h"
 #include "SkImage.h"
 #include "SkShader.h"
 #include "SkSurface.h"
 
 #include "Test.h"
 
-void testBitmapEquality(skiatest::Reporter* reporter, SkBitmap& bm1, SkBitmap& bm2) {
-    SkAutoLockPixels lockBm1(bm1);
-    SkAutoLockPixels lockBm2(bm2);
+void testBitmapEquality(skiatest::Reporter* reporter, const SkBitmap& src, const SkBitmap& dst,
+                        const char label[]) {
+    SkAutoLockPixels lockBm1(src);
+    SkAutoLockPixels lockBm2(dst);
 
-    REPORTER_ASSERT(reporter, bm1.getSize() == bm2.getSize());
-    REPORTER_ASSERT(reporter, 0 == memcmp(bm1.getPixels(), bm2.getPixels(), bm1.getSize()));
+    REPORTER_ASSERT(reporter, src.getSize() == dst.getSize());
+    if (memcmp(src.getPixels(), dst.getPixels(), dst.getSize())) {
+        SkDebugf("testBitmapEquality %s\n", label);
+        for (int y = 0; y < src.height(); ++y) {
+            for (int x = 0; x < src.width(); ++x) {
+                SkDebugf("(%d %d) src=%08X dst=%08X\n", x, y, src.getColor(x, y), dst.getColor(x, y));
+            }
+        }
+        REPORTER_ASSERT(reporter, false);
+    }
 }
 
 void paintSource(SkSurface* sourceSurface) {
     SkCanvas* sourceCanvas = sourceSurface->getCanvas();
     sourceCanvas->clear(0xFFDEDEDE);
 
     SkPaint paintColor;
     paintColor.setColor(0xFFFF0000);
     paintColor.setStyle(SkPaint::kFill_Style);
 
     SkRect rect = SkRect::MakeXYWH(
             SkIntToScalar(1),
             SkIntToScalar(0),
             SkIntToScalar(1),
             SkIntToScalar(sourceSurface->height()));
 
     sourceCanvas->drawRect(rect, paintColor);
 }
 
-void runShaderTest(skiatest::Reporter* reporter, SkSurface* sourceSurface, SkSurface* destinationSurface, SkImageInfo& info) {
+void runShaderTest(skiatest::Reporter* reporter, SkSurface* sourceSurface,
+                   SkSurface* destinationSurface, SkImageInfo& info, const char label[]) {
     paintSource(sourceSurface);
 
     SkAutoTUnref<SkImage> sourceImage(sourceSurface->newImageSnapshot());
     SkAutoTUnref<SkShader> sourceShader(sourceImage->newShader(
             SkShader::kRepeat_TileMode,
             SkShader::kRepeat_TileMode));
 
     SkPaint paint;
     paint.setShader(sourceShader);
 
     SkCanvas* destinationCanvas = destinationSurface->getCanvas();
     destinationCanvas->clear(SK_ColorTRANSPARENT);
     destinationCanvas->drawPaint(paint);
 
     SkIRect rect = info.bounds();
 
-    SkBitmap bmOrig;
-    sourceSurface->getCanvas()->readPixels(rect, &bmOrig);
+    SkBitmap srcBM;
+    sourceSurface->getCanvas()->readPixels(rect, &srcBM);
 
 
-    SkBitmap bm;
-    destinationCanvas->readPixels(rect, &bm);
+    SkBitmap dstBM;
+    destinationCanvas->readPixels(rect, &dstBM);
 
-    testBitmapEquality(reporter, bmOrig, bm);
+    testBitmapEquality(reporter, srcBM, dstBM, label);
 
 
 
     // Test with a translated shader
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(-1), SkIntToScalar(0));
 
     SkAutoTUnref<SkShader> sourceShaderTranslated(sourceImage->newShader(
             SkShader::kRepeat_TileMode,
             SkShader::kRepeat_TileMode,
             &matrix));
 
     destinationCanvas->clear(SK_ColorTRANSPARENT);
 
     SkPaint paintTranslated;
     paintTranslated.setShader(sourceShaderTranslated);
 
     destinationCanvas->drawPaint(paintTranslated);
 
     SkBitmap bmt;
     destinationCanvas->readPixels(rect, &bmt);
 
     //  Test correctness
     {
         SkAutoLockPixels lockBm(bmt);
         for (int y = 0; y < info.height(); y++) {
-            REPORTER_ASSERT(reporter, 0xFFFF0000 == bmt.getColor(0, y));
+            if (0xFFFF0000 != bmt.getColor(0, y)) {
+                SkDebugf("y = %d for %s\n", y, label);
+                REPORTER_ASSERT(reporter, 0xFFFF0000 == bmt.getColor(0, y));
+            }
 
             for (int x = 1; x < info.width(); x++) {
+                if (0xFFDEDEDE != bmt.getColor(x, y)) {
+                    SkDebugf("(%d %d) color = %x for %s\n", x, y, bmt.getColor(x, y), label);
+                }
                 REPORTER_ASSERT(reporter, 0xFFDEDEDE == bmt.getColor(x, y));
             }
         }
     }
 }
 
 DEF_TEST(ImageNewShader, reporter) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
     SkAutoTUnref<SkSurface> sourceSurface(SkSurface::NewRaster(info));
     SkAutoTUnref<SkSurface> destinationSurface(SkSurface::NewRaster(info));
 
-    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info, "raster");
 }
 
 #if SK_SUPPORT_GPU
 
 void gpuToGpu(skiatest::Reporter* reporter, GrContext* context) {
+    // if we change these to 5,5, this fails on Nexus 7 w/ Tegra 3. See skbug.com/4365

[reed1, 2015/09/21 21:02:06]

Will remove this comment.

     SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
     SkAutoTUnref<SkSurface> sourceSurface(
         SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info));
     SkAutoTUnref<SkSurface> destinationSurface(
         SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info));
 
-    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info, "gpu");
 }
 
 void gpuToRaster(skiatest::Reporter* reporter, GrContext* context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
     SkAutoTUnref<SkSurface> sourceSurface(SkSurface::NewRenderTarget(context,
         SkSurface::kNo_Budgeted, info));
     SkAutoTUnref<SkSurface> destinationSurface(SkSurface::NewRaster(info));
 
-    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info, "gpu-raster");
 }
 
 void rasterToGpu(skiatest::Reporter* reporter, GrContext* context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
     SkAutoTUnref<SkSurface> sourceSurface(SkSurface::NewRaster(info));
     SkAutoTUnref<SkSurface> destinationSurface(SkSurface::NewRenderTarget(context,
         SkSurface::kNo_Budgeted, info));
 
-    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
+    runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info, "raster-gpu");
 }
 
 DEF_GPUTEST(ImageNewShader_GPU, reporter, factory) {
     for (int i = 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
         GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
 
         if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
             continue;
         }
 
         GrContext* context = factory->get(glCtxType);
 
         if (nullptr == context) {
             continue;
         }
 
         //  GPU -> GPU
         gpuToGpu(reporter, context);
 
         //  GPU -> RASTER
         gpuToRaster(reporter, context);
 
         //  RASTER -> GPU
         rasterToGpu(reporter, context);
     }
 }
 
 #endif