Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2017 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkTypes.h"
      9 
     10 #include "SkCanvas.h"
     11 #include "SkSurface.h"
     12 
     13 #include "GrContext.h"
     14 #include "GrContextPriv.h"
     15 #include "Test.h"
     16 
     17 static SkBitmap read_pixels(sk_sp<SkSurface> surface, SkColor initColor) {
     18     SkBitmap bmp;
     19     bmp.allocN32Pixels(surface->width(), surface->height());
     20     bmp.eraseColor(initColor);
     21     if (!surface->readPixels(bmp, 0, 0)) {
     22         SkDebugf("readPixels failed\n");
     23     }
     24     return bmp;
     25 }
     26 
     27 static sk_sp<SkSurface> make_surface(GrContext* context) {
     28     SkImageInfo info = SkImageInfo::Make(50, 50, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
     29     return SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 4,
     30                                        kBottomLeft_GrSurfaceOrigin, nullptr);
     31 }
     32 
     33 static void test_bug_6653(GrContext* ctx, skiatest::Reporter* reporter, const char* label) {
     34     SkRect rect = SkRect::MakeWH(50, 50);
     35 
     36     SkPaint paint;
     37     paint.setColor(SK_ColorWHITE);
     38     paint.setStrokeWidth(5);
     39     paint.setStyle(SkPaint::kStroke_Style);
     40 
     41     // The one device that fails this test (Galaxy S6) does so in a flaky fashion. Trying many
     42     // times makes it more likely to fail. Also, interacting with the phone (eg swiping between
     43     // different home screens) while the test is running makes it fail close to 100%.
     44     static const int kNumIterations = 50;
     45 
     46     for (int i = 0; i < kNumIterations; ++i) {
     47         auto s0 = make_surface(ctx);
     48         if (!s0) {
     49             // MSAA may not be supported
     50             return;
     51         }
     52 
     53         auto s1 = make_surface(ctx);
     54         s1->getCanvas()->clear(SK_ColorBLACK);
     55         s1->getCanvas()->drawOval(rect, paint);
     56         SkBitmap b1 = read_pixels(s1, SK_ColorBLACK);
     57         s1 = nullptr;
     58 
     59         // The bug requires that all three of the following surfaces are cleared to the same color
     60         auto s2 = make_surface(ctx);
     61         s2->getCanvas()->clear(SK_ColorBLUE);
     62         SkBitmap b2 = read_pixels(s2, SK_ColorBLACK);
     63         s2 = nullptr;
     64 
     65         auto s3 = make_surface(ctx);
     66         s3->getCanvas()->clear(SK_ColorBLUE);
     67         SkBitmap b3 = read_pixels(s3, SK_ColorBLACK);
     68         s0->getCanvas()->drawBitmap(b3, 0, 0);
     69         s3 = nullptr;
     70 
     71         auto s4 = make_surface(ctx);
     72         s4->getCanvas()->clear(SK_ColorBLUE);
     73         s4->getCanvas()->drawOval(rect, paint);
     74 
     75         // When this fails, b4 will "succeed", but return an empty bitmap (containing just the
     76         // clear color). Regardless, b5 will contain the oval that was just drawn, so diffing the
     77         // two bitmaps tests for the failure case. Initialize the bitmaps to different colors so
     78         // that if the readPixels doesn't work, this test will always fail.
     79         SkBitmap b4 = read_pixels(s4, SK_ColorRED);
     80         SkBitmap b5 = read_pixels(s4, SK_ColorGREEN);
     81 
     82         bool match = true;
     83         for (int y = 0; y < b4.height() && match; ++y) {
     84             for (int x = 0; x < b4.width() && match; ++x) {
     85                 uint32_t pixelA = *b4.getAddr32(x, y);
     86                 uint32_t pixelB = *b5.getAddr32(x, y);
     87                 if (pixelA != pixelB) {
     88                     match = false;
     89                 }
     90             }
     91         }
     92 
     93         REPORTER_ASSERT(reporter, match, label);
     94     }
     95 }
     96 
     97 // Tests that readPixels returns up-to-date results. This has failed on several GPUs,
     98 // from multiple vendors, in MSAA mode.
     99 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(skbug6653, reporter, ctxInfo) {
    100     GrContext* ctx = ctxInfo.grContext();
    101     test_bug_6653(ctx, reporter, "Default");
    102 }
    103 
    104 // Same as above, but without explicit resource allocation.
    105 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(skbug6653_noExplicitResourceAllocation, reporter, ctxInfo) {
    106     GrContext* ctx = ctxInfo.grContext();
    107     ctx->flush();
    108     ctx->contextPriv().resourceProvider()->testingOnly_setExplicitlyAllocateGPUResources(false);
    109     test_bug_6653(ctx, reporter, "No ERA");
    110 }
    111