Add gm for displaying different variants of 8888.

gm/all_bitmap_configs.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 "sk_tool_utils.h"
 #include "SkSurface.h"
 #include "Resources.h"
@@ skipping 173 matching lines @@
     canvas->translate(0.0f, SkIntToScalar(SCALE));
     SkBitmap bitmapA8 = make_bitmap(kAlpha_8_SkColorType);
     draw(canvas, p, bitmapA8, kAlpha_8_SkColorType, "Alpha 8");
 
     p.setColor(SK_ColorRED);
     canvas->translate(0.0f, SkIntToScalar(SCALE));
     SkBitmap bitmapG8 = make_bitmap(kGray_8_SkColorType);
     draw(canvas, p, bitmapG8, kGray_8_SkColorType, "Gray 8");
 }
 
-// Works on Ganesh, fails on Raster.
 sk_sp<SkImage> make_not_native32_color_wheel() {
     SkBitmap n32bitmap, notN32bitmap;
     n32bitmap.allocN32Pixels(SCALE, SCALE);
     n32bitmap.eraseColor(SK_ColorTRANSPARENT);
     SkCanvas n32canvas(n32bitmap);
     color_wheel_native(&n32canvas);
     n32canvas.flush();
     #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
         const SkColorType ct = kRGBA_8888_SkColorType;
     #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
         const SkColorType ct = kBGRA_8888_SkColorType;
     #endif
     static_assert(ct != kN32_SkColorType, "BRGA!=RGBA");
     SkAssertResult(n32bitmap.copyTo(&notN32bitmap, ct));
     SkASSERT(notN32bitmap.colorType() == ct);
     return SkImage::MakeFromBitmap(notN32bitmap);
 }
 
 DEF_SIMPLE_GM(not_native32_bitmap_config, canvas, SCALE, SCALE) {
     sk_sp<SkImage> notN32image(make_not_native32_color_wheel());
     SkASSERT(notN32image);
     sk_tool_utils::draw_checkerboard(canvas, SK_ColorLTGRAY, SK_ColorWHITE, 8);
     canvas->drawImage(notN32image.get(), 0.0f, 0.0f);
 }
+
+static uint32_t make_pixel(int x, int y, SkAlphaType alphaType) {
+    SkASSERT(x >= 0 && x < SCALE);
+    SkASSERT(y >= 0 && y < SCALE);
+
+    SkScalar R = SCALE / 2.0f;
+
+    uint32_t alpha = 0x00;
+
+    if ((x - R) * (x - R) + (y - R) * (y - R) < R * R) {
+        alpha = 0xFF;
+    }
+
+    uint32_t component;
+    switch (alphaType) {
+        case kPremul_SkAlphaType:
+            component = alpha;
+            break;
+        case kUnpremul_SkAlphaType:
+            component = 0xFF;
+            break;
+        default:
+            SkFAIL("Should not get here - invalid alpha type");
+            return 0xFF000000;
+    }
+    return alpha << 24 | component;
+}
+
+static void make_color_test_bitmap_variant(
+    SkColorType colorType,
+    SkAlphaType alphaType,
+    SkColorProfileType profile,
+    SkBitmap* bm)
+{
+    SkASSERT(colorType == kRGBA_8888_SkColorType || colorType == kBGRA_8888_SkColorType);
+    SkASSERT(alphaType == kPremul_SkAlphaType || alphaType == kUnpremul_SkAlphaType);
+    bm->allocPixels(
+        SkImageInfo::Make(SCALE, SCALE, colorType, alphaType, profile));
+    SkPixmap pm;
+    bm->peekPixels(&pm);
+    for (int y = 0; y < bm->height(); y++) {
+        for (int x = 0; x < bm->width(); x++) {
+            *pm.writable_addr32(x, y) = make_pixel(x, y, alphaType);
+        }
+    }
+}
+
+DEF_SIMPLE_GM(all_variants_8888, canvas, 4 * SCALE + 30, 2 * SCALE + 10) {
+    sk_tool_utils::draw_checkerboard(canvas, SK_ColorLTGRAY, SK_ColorWHITE, 8);
+
+    for (auto profile : {kSRGB_SkColorProfileType, kLinear_SkColorProfileType}) {
+        canvas->save();
+        for (auto alphaType : {kPremul_SkAlphaType, kUnpremul_SkAlphaType}) {
+            canvas->save();
+            for (auto colorType : {kRGBA_8888_SkColorType, kBGRA_8888_SkColorType}) {
+                SkBitmap bm;
+                make_color_test_bitmap_variant(colorType, alphaType, profile, &bm);
+                canvas->drawBitmap(bm, 0.0f, 0.0f);
+                canvas->translate(SCALE + 10, 0.0f);
+            }
+            canvas->restore();
+            canvas->translate(0.0f, SCALE + 10);
+        }
+        canvas->restore();
+        canvas->translate(2 * (SCALE + 10), 0.0f);
+    }
+}