/*
 * Copyright 2025 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPaint.h"
#include "include/core/SkRect.h"
#include "include/core/SkSurface.h"
#include "include/effects/SkBlurMaskFilter.h"
#include "include/gpu/graphite/Context.h"
#include "include/gpu/graphite/Recorder.h"
#include "include/gpu/graphite/Surface.h"
#include "tests/Test.h"

#include "src/gpu/graphite/Surface_Graphite.h"

using namespace skgpu::graphite;

namespace {

bool colors_are_similar(SkColor c1, SkColor c2, int tolerance) {
    if (std::abs((int)SkColorGetA(c1) - (int)SkColorGetA(c2)) > tolerance) return false;
    if (std::abs((int)SkColorGetR(c1) - (int)SkColorGetR(c2)) > tolerance) return false;
    if (std::abs((int)SkColorGetG(c1) - (int)SkColorGetG(c2)) > tolerance) return false;
    if (std::abs((int)SkColorGetB(c1) - (int)SkColorGetB(c2)) > tolerance) return false;
    return true;
}

bool layer_test(SkBitmap& bitmap, Context* context, SkBlendMode blendMode) {
    auto recorder = context->makeRecorder();
    SkImageInfo info = SkImageInfo::Make(256, 256, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(recorder.get(), info);
    SkCanvas* canvas = surface->getCanvas();

    SkPaint blendPaint;
    blendPaint.setBlendMode(blendMode);

    SkPaint bluePaint;
    bluePaint.setColor(0xFF0099FF);
    canvas->clear(SK_ColorTRANSPARENT);
    canvas->drawRect(SkRect::MakeXYWH(5, 5, 45, 45), bluePaint);

    canvas->saveLayer(nullptr, &blendPaint);
    SkPaint greenPaint;
    greenPaint.setColor(0xCC33FF99);
    canvas->clear(SK_ColorTRANSPARENT);
    canvas->drawRect(SkRect::MakeXYWH(30, 15, 45, 45), greenPaint);
    canvas->restore();

    canvas->saveLayer(nullptr, &blendPaint);
    SkPaint redPaint;
    redPaint.setColor(0xFFFF3300);
    canvas->clear(SK_ColorTRANSPARENT);
    canvas->drawRect(SkRect::MakeXYWH(20, 25, 45, 45), redPaint);
    canvas->restore();

    bitmap.allocPixels(info);
    return canvas->readPixels(bitmap, 0, 0);
}

} // namespace

/*
    This test creates a dependency chain between different surfaces, by forcing a
    Device::makeImageCopy through makeImageSnapshot().

    Device::makeImageCopy first calls flushPendingWork(nullptr), then Image::Copy. However because
    flushPendingWork *only flushes tasks from B*, when Image::Copy adds the copy task directly to
    the recorder's root task list, A is not yet flushed. So when the recorder is snapped in
    readPixels, only B is copied into C.

    The incorrect ordering.
    =========== RECORDING ===========
    **** FLUSH TOKEN 1 Snap ****
    0: Draw Task (target=0x120e84570)   <-- B's drawTask
    └── RenderPass Task
    1: Copy TtoT Task                   <-- the copy task from B to C, A has drawn yet!
    2: Draw Task (target=0x120e834a0)   <-- A's drawTask
    └── RenderPass Task
    3: Draw Task (target=0x120e85690)   <-- C's drawTask
    └── RenderPass Task
    -------------- END --------------

    The correct ordering:
    =========== RECORDING ===========
    **** FLUSH TOKEN 1 Snap ****
    0: Draw Task (target=0x120e834a0)   <-- A's drawTask
    └── RenderPass Task
    1: Draw Task (target=0x120e84570)   <-- B's drawTask
    └── RenderPass Task
    2: Copy TtoT Task                   <-- the copy task from B to C
    3: Draw Task (target=0x120e85690)   <-- C's drawContext
    └── RenderPass Task
    -------------- END --------------
*/

DEF_GRAPHITE_TEST_FOR_CONTEXTS(NotifyInUseTestSnapshot, /*filter=*/nullptr, reporter, context,
                               testContext, CtsEnforcement::kNextRelease) {
    auto recorder = context->makeRecorder();
    SkImageInfo info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType);

    // "A"
    sk_sp<SkSurface> surfaceA = SkSurfaces::RenderTarget(recorder.get(), info);
    SkCanvas* canvasA = surfaceA->getCanvas();
    SkPaint greenPaint;
    greenPaint.setColor(SK_ColorGREEN);
    canvasA->drawRect(SkRect::Make(info.bounds()), greenPaint);
    sk_sp<SkImage> imageA = SkSurfaces::AsImage(surfaceA);
    REPORTER_ASSERT(reporter, imageA);

    // "B"
    sk_sp<SkSurface> surfaceB = SkSurfaces::RenderTarget(recorder.get(), info);
    SkCanvas* canvasB = surfaceB->getCanvas();
    canvasB->clear(SK_ColorBLACK);
    canvasB->drawImage(imageA, 0, 0);

    // "C"
    sk_sp<SkSurface> surfaceC = SkSurfaces::RenderTarget(recorder.get(), info);
    SkCanvas* canvasC = surfaceC->getCanvas();
    canvasC->clear(SK_ColorBLACK);
    canvasC->drawImage(surfaceB->makeImageSnapshot(), 0, 0);

    // Recorder snap inside readPixels
    SkBitmap bitmap;
    bitmap.allocPixels(info);
    REPORTER_ASSERT(reporter, surfaceC->readPixels(bitmap, 0, 0));

    SkColor topLeft = bitmap.getColor(0, 0);
    REPORTER_ASSERT(reporter, topLeft == SK_ColorGREEN,
                    "Expected green pixel from surface C, got 0x%08X", topLeft);
}

/*
    This test confirms that mixing reads from an image view of a surface (SkSurfaces::AsImage) with
    writes to that surface's canvas order tasks correctly. At a high level, the flow of draws and
    flushes should be:

    DrawBlue to A
    DrawA to left of B (flushes A's tasks)
    DrawRed to A
    DrawA to right of B (flushes B's tasks, then A's tasks)

    This should produce the following task graph:

    =========== RECORDING 1 ===========
    **** FLUSH TOKEN 1 Recorder::Snap ****
    0: Draw Task=0x600000433e80 (Target=0x600002e04690) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (A1)
    1: Draw Task=0x600000433f00 (Target=0x600002e045a0) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (B1)
    2: Draw Task=0x600000433fc0 (Target=0x600002e04690) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (A2)
    3: Draw Task=0x60000041dd00 (Target=0x600002e045a0) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (B2)
    --------------- END ---------------

    Without tracking the fact that B depends on A's prior contents, when notifyInUse() incorrectly
    was only flushing A's tasks, the task graph would be the following. This results in the final
    contents of A being used for both of its draws into B:

    =========== RECORDING 1 ===========
    **** FLUSH TOKEN 1 Recorder::Snap ****
    0: Draw Task=0x600001a27bc0 (Target=0x6000030084b0) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (A1)
    1: Draw Task=0x600001a27d00 (Target=0x6000030084b0) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (A2)
    2: Draw Task=0x600001a27c40 (Target=0x6000030083c0) (Label=SkSurfaceRenderTarget)
    └── RenderPass Task (B1+B2, only samples A2's state)
    --------------- END ---------------

*/
DEF_GRAPHITE_TEST_FOR_CONTEXTS(NotifyInUseTestAsImage, /*filter=*/nullptr, reporter, context,
                               testContext, CtsEnforcement::kNextRelease) {
    auto recorder = context->makeRecorder();
    SkImageInfo aInfo = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
    SkImageInfo bInfo = SkImageInfo::Make(20, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType);

    // "A1"
    sk_sp<SkSurface> surfaceA = SkSurfaces::RenderTarget(recorder.get(), aInfo);
    surfaceA->getCanvas()->clear(SK_ColorBLUE);
    sk_sp<SkImage> imageA = SkSurfaces::AsImage(surfaceA);
    REPORTER_ASSERT(reporter, imageA);

    // "B1"
    sk_sp<SkSurface> surfaceB = SkSurfaces::RenderTarget(recorder.get(), bInfo);
    SkCanvas* canvasB = surfaceB->getCanvas();
    canvasB->clear(SK_ColorBLACK);
    canvasB->drawImage(imageA, 0, 0); // Should see A's blue clear in left half of B

    // "A2"
    surfaceA->getCanvas()->clear(SK_ColorRED);

    // "B2"
    canvasB->drawImage(imageA, 10, 0); // Should see A's now-red clear in right half of B

    // Recorder snaps inside readPixels
    SkBitmap bitmap;
    bitmap.allocPixels(bInfo);
    REPORTER_ASSERT(reporter, surfaceB->readPixels(bitmap, 0, 0));


    SkColor leftB = bitmap.getColor(5, 5);
    REPORTER_ASSERT(reporter, leftB == SK_ColorBLUE,
                    "Expected blue pixel from surface B's left half, got 0x%08X", leftB);
    SkColor rightB = bitmap.getColor(15, 5);
    REPORTER_ASSERT(reporter, rightB == SK_ColorRED,
                    "Expected red pixel from surface B's right half, got 0x%08X", rightB);
}

/*
    These tests replicate the compositing behavior in blink's canvas2d. Due to the use of save
    layers, the final order of draw tasks on the root task list does not match the order of draw
    calls in the code. At a high level the flow of draws and flushes looks like this:

    DrawBlue
        DrawGeometry DrawContext0
    SaveLayer SkBlendMode::kMultiply

    DrawGreen
        DrawGeometry DrawContext1
    Restore0
        SetImmutable FlushPendingWork
        DrawSpecial DrawGeometry DrawContext0
    SaveLayer SkBlendMode::kMultiply

    DrawRed
        DrawGeometry DrawContext2
    Restore1
        SetImmutable FlushPendingWork
        DrawSpecial DrawGeometry DrawContext0

    Snap
        FlushTrackedDevices

    ------------------------------------------------------------------------------------------------

    Some blends, like multiply, depend on prior draws. However, on devices without frame buffer
    fetch, this creates a dependency hazard because the destination surface must be copied to be
    read in for the blending. This means flushing prior draws to the root task list *before* the
    current draw---flushBeforeDraw. Dependency on prior draws is communicated through
    Image_Base::notifyInUse, but correct dependency ordering is contingent on the ordering of
    flushBeforeDraw and notifyInUse relative to each other.

    Calling notifyInUse prior to flushBeforeDraw causes the dependency draw task to be added as a
    child task of the current draw instead of flushing to the root task list. In many cases, adding
    the draw as a child of the dependent draw task is ok because child tasks execute prior to their
    parent task. However, if a later draw *also* depends on the now child draw, an incorrect draw
    order may arise.

    Using the SkBlendMode::Multiply version of the test as an example:

    Incorrect ordering:
    1) Green flushed to the root task list by restore0 setImmutable

    2) Green gets added as child of Blue restore0 drawSpecial
    3) Blue+Green gets flushed as flushBeforeDraw restore0 drawSpecial

    4) Red flushed to the root task list by restore1 setImmutable

    5) Red gets added as child of Blue+Green+Red+Blend restore1 drawSpecial
    6) Blue+Green+Red+Blend gets flushed as flushBeforeDraw restore1 drawSpecial

    7) Malformed gets flushed as flushTrackedDevices snap

    Correct ordering:
    1) Green flushed to the root task list by restore0 setImmutable

    2) Blue gets flushed as flushBeforeDraw restore0 drawSpecial
    3) Green added as child of Blue+Green+Blend restore0 drawSpecial

    4) Red flushed to the root task list by restore1 setImmutable

    5) Blue+Green+Blend flushed as flushBeforeDraw restore1 drawSpecial
    6) Red added as child of Blue+Green+Red+Blend restore1 drawSpecial

    7) Blue+Green+Red+Blend flushed as flushTrackedDevices snap

    SkBlendMode::Multiply incorrect ordering:
    =========== RECORDING 1 ===========
    **** FLUSH TOKEN 154 Recorder::Snap ****
    0: Draw Task (target=0x17252f6c0) (DC=0x17253b7d0)  <-- Draw Green into layer
    └── RenderPass Task
    1: Draw Task (target=0x172544bf0) (DC=0x1725290d0)  <-- Draw blue into main layer
    │   Draw Task (target=0x17252f6c0) (DC=0x17253b7d0) <-- Green is added as child of blue
    │   └── RenderPass Task
    └── RenderPass Task
    2: Draw Task (target=0x17254c3d0) (DC=0x172530cc0)  <-- Draw red into layer
    └── RenderPass Task
    3: Draw Task (target=0x172544bf0) (DC=0x1725290d0)  <-- Blend blue with red!
    │   Draw Task (target=0x17254c3d0) (DC=0x172530cc0) <-- Red is added as child of blend
    │   └── RenderPass Task
    │   Copy TtoT Task: Src=0x172544bf0 Dst=0x172547880 <-- Texture Copy because no FbFetch
    └── RenderPass Task
    4: Draw Task (target=0x172544bf0) (DC=0x1725290d0)  <-- ATTEMPT to blend blue+red with green!
    │   Copy TtoT Task: Src=0x172544bf0 Dst=0x17254c130 <-- Copy but there's no lastDrawTask !
    └── RenderPass Task
    --------------- END ---------------

    The correct ordering:
    =========== RECORDING 1 ===========
    **** FLUSH TOKEN 181 Recorder::Snap ****
    0: Draw Task (target=0x349db7690) (DC=0x349d856b0)  <-- Draw green into layer
    └── RenderPass Task
    1: Draw Task (target=0x349db7010) (DC=0x349d98a80)  <-- Draw blue into main layer
    └── RenderPass Task
    2: Draw Task (target=0x349d99f90) (DC=0x349d981d0)  <-- Draw red into layer
    └── RenderPass Task
    3: Draw Task (target=0x349db7010) (DC=0x349d98a80)  <-- Blend blue with green
    │   Draw Task (target=0x349db7690) (DC=0x349d856b0) <-- Green is correctly added as child
    │   └── RenderPass Task
    │   Copy TtoT Task: Src=0x349db7010 Dst=0x349d96b90 <-- Texture Copy because no FbFetch
    └── RenderPass Task
    4: Draw Task (target=0x349db7010) (DC=0x349d98a80)  <-- Blend blue+green with red
    │   Draw Task (target=0x349d99f90) (DC=0x349d981d0) <-- Red is correctly added as child
    │   └── RenderPass Task
    │   Copy TtoT Task: Src=0x349db7010 Dst=0x349d988a0 <-- Texture Copy because no FbFetch
    └── RenderPass Task
    --------------- END ---------------
*/

#define DEFINE_LAYER_BLEND_TEST(TestName, BlendMode, ExpectedBlueOnly, ExpectedGreenOnly,        \
                                ExpectedBlueAndGreen, ExpectedRedOnly, ExpectedAllOverlap)       \
DEF_GRAPHITE_TEST_FOR_CONTEXTS(NotifyInUseTestLayer ## TestName, /*filter=*/nullptr, reporter,   \
                               context, testContext, CtsEnforcement::kNextRelease) {             \
    SkBitmap bitmap;                                                                             \
    REPORTER_ASSERT(reporter, layer_test(bitmap, context, BlendMode),                            \
                        "Failed to read pixels for BlendMode '%s'",                              \
                        SkBlendMode_Name(BlendMode));                                            \
                                                                                                 \
    constexpr int kTolerance = 2;                                                                \
    SkColor blueOnly = bitmap.getColor(10, 10);                                                  \
    REPORTER_ASSERT(reporter, colors_are_similar(blueOnly, ExpectedBlueOnly, kTolerance),        \
                    "Pt(10,10) BlendMode '%s': Expected blue-only ~0x%08X, got 0x%08X",          \
                    SkBlendMode_Name(BlendMode), (uint32_t)ExpectedBlueOnly, blueOnly);          \
                                                                                                 \
    SkColor greenOnly = bitmap.getColor(70, 30);                                                 \
    REPORTER_ASSERT(reporter, colors_are_similar(greenOnly, ExpectedGreenOnly, kTolerance),      \
                    "Pt(70,30) BlendMode '%s': Expected green-only ~0x%08X, got 0x%08X",         \
                    SkBlendMode_Name(BlendMode), (uint32_t)ExpectedGreenOnly, greenOnly);        \
                                                                                                 \
    SkColor blueAndGreen = bitmap.getColor(40, 20);                                              \
    REPORTER_ASSERT(reporter, colors_are_similar(blueAndGreen, ExpectedBlueAndGreen, kTolerance),\
                    "Pt(40,20) BlendMode '%s': Expected blue/green ~0x%08X, got 0x%08X",         \
                    SkBlendMode_Name(BlendMode), (uint32_t)ExpectedBlueAndGreen, blueAndGreen);  \
                                                                                                 \
    SkColor redOnly = bitmap.getColor(25, 68);                                                   \
    REPORTER_ASSERT(reporter, colors_are_similar(redOnly, ExpectedRedOnly, kTolerance),          \
                    "Pt(25,68) BlendMode '%s': Expected red-only ~0x%08X, got 0x%08X",           \
                    SkBlendMode_Name(BlendMode), (uint32_t)ExpectedRedOnly, redOnly);            \
                                                                                                 \
    SkColor allOverlap = bitmap.getColor(40, 40);                                                \
    REPORTER_ASSERT(reporter, colors_are_similar(allOverlap, ExpectedAllOverlap, kTolerance),    \
                    "Pt(40,40) BlendMode '%s': Expected all-overlap ~0x%08X, got 0x%08X",        \
                    SkBlendMode_Name(BlendMode), (uint32_t)ExpectedAllOverlap, allOverlap);      \
}

// Basic Porter-Duff blend modes
DEFINE_LAYER_BLEND_TEST(Clear, SkBlendMode::kClear, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
                                                    0x00000000)
DEFINE_LAYER_BLEND_TEST(Src, SkBlendMode::kSrc, 0x00000000, 0x00000000, 0x00000000, 0xFFFF3300,
                                                0xFFFF3300)
DEFINE_LAYER_BLEND_TEST(Dst, SkBlendMode::kDst, 0xFF0099FF, 0x00000000, 0xFF0099FF, 0x00000000,
                                                0xFF0099FF)
DEFINE_LAYER_BLEND_TEST(SrcOver, SkBlendMode::kSrcOver, 0xFF0099FF, 0xCC33FF99, 0xFF29EBAD,
                                                        0xFFFF3300, 0xFFFF3300)
DEFINE_LAYER_BLEND_TEST(DstOver, SkBlendMode::kDstOver, 0xFF0099FF, 0xCC33FF99, 0xFF0099FF,
                                                        0xFFFD3302, 0xFF0099FF)
DEFINE_LAYER_BLEND_TEST(SrcIn, SkBlendMode::kSrcIn, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
                                                    0xCCFF3300)
DEFINE_LAYER_BLEND_TEST(DstIn, SkBlendMode::kDstIn, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
                                                    0xCC0099FF)
DEFINE_LAYER_BLEND_TEST(SrcOut, SkBlendMode::kSrcOut, 0x00000000, 0x00000000, 0x00000000,
                                                      0xFDFF3300, 0xFFFF3300)
DEFINE_LAYER_BLEND_TEST(DstOut, SkBlendMode::kDstOut, 0xFF0099FF, 0x00000000, 0x33009BFF,
                                                      0x00000000, 0x00000000)
DEFINE_LAYER_BLEND_TEST(SrcATop, SkBlendMode::kSrcATop, 0xFF0099FF, 0x00000000, 0xFF29EBAD,
                                                        0x00000000, 0xFFFF3300)
DEFINE_LAYER_BLEND_TEST(DstATop, SkBlendMode::kDstATop, 0x00000000, 0x00000000, 0x00000000,
                                                        0xFFFD3302, 0xFF3384CC)
DEFINE_LAYER_BLEND_TEST(Xor, SkBlendMode::kXor, 0xFF0099FF, 0xCC33FF99, 0x33009BFF, 0xFDFF3300,
                                                0xCCFF3300)
DEFINE_LAYER_BLEND_TEST(Plus, SkBlendMode::kPlus, 0xFF0099FF, 0xCC33FF99, 0xFF29FFFF, 0xFFFF3302,
                                                  0xFFFFFFFF)
DEFINE_LAYER_BLEND_TEST(Modulate, SkBlendMode::kModulate, 0x00000000, 0x00000000, 0x00000000,
                                                          0x00000000, 0xCC001E00)
DEFINE_LAYER_BLEND_TEST(Screen, SkBlendMode::kScreen, 0xFF0099FF, 0xCC33FF99, 0xFF29EBFF,
                                                      0xFFFF3302, 0xFFFFEFFF)

// Advanced, non-separable blend modes
DEFINE_LAYER_BLEND_TEST(Overlay, SkBlendMode::kOverlay, 0xFF0099FF, 0xCC33FF99, 0xFF00EBFF,
                                                        0xFFFD3302, 0xFF00DFFF)
DEFINE_LAYER_BLEND_TEST(Darken, SkBlendMode::kDarken, 0xFF0099FF, 0xCC33FF99, 0xFF0099AD,
                                                      0xFFFD3300, 0xFF003300)
DEFINE_LAYER_BLEND_TEST(Lighten, SkBlendMode::kLighten, 0xFF0099FF, 0xCC33FF99, 0xFF29EBFF,
                                                        0xFFFF3302, 0xFFFFEBFF)
DEFINE_LAYER_BLEND_TEST(ColorDodge, SkBlendMode::kColorDodge, 0xFF0099FF, 0xCC33FF99, 0xFF00EBFF,
                                                              0xFFFD3302, 0xFF00FFFF)
DEFINE_LAYER_BLEND_TEST(ColorBurn, SkBlendMode::kColorBurn, 0xFF0099FF, 0xCC33FF99, 0xFF0099FF,
                                                            0xFFFD3302, 0xFF0000FF)
DEFINE_LAYER_BLEND_TEST(HardLight, SkBlendMode::kHardLight, 0xFF0099FF, 0xCC33FF99, 0xFF00EBFF,
                                                            0xFFFF3300, 0xFFFF5E00)
DEFINE_LAYER_BLEND_TEST(SoftLight, SkBlendMode::kSoftLight, 0xFF0099FF, 0xCC33FF99, 0xFF00BDFF,
                                                            0xFFFD3302, 0xFF00A0FF)
DEFINE_LAYER_BLEND_TEST(Difference, SkBlendMode::kDifference, 0xFF0099FF, 0xCC33FF99, 0xFF297085,
                                                              0xFFFF3302, 0xFFD63D85)
DEFINE_LAYER_BLEND_TEST(Exclusion, SkBlendMode::kExclusion, 0xFF0099FF, 0xCC33FF99, 0xFF297085,
                                                            0xFFFF3302, 0xFFD67685)
DEFINE_LAYER_BLEND_TEST(Multiply, SkBlendMode::kMultiply, 0xFF0099FF, 0xCC33FF99, 0xFF0099AD,
                                                          0xFFFD3300, 0xFF001F00)

// HSL component blend modes
DEFINE_LAYER_BLEND_TEST(Hue, SkBlendMode::kHue, 0xFF0099FF, 0xCC33FF99, 0xFF00B17C, 0xFFFE3300,
                                                0xFFDD4F2C)
DEFINE_LAYER_BLEND_TEST(Saturation, SkBlendMode::kSaturation, 0xFF0099FF, 0xCC33FF99, 0xFF1393E9,
                                                              0xFFFD3302, 0xFF0099FF)
DEFINE_LAYER_BLEND_TEST(Color, SkBlendMode::kColor, 0xFF0099FF, 0xCC33FF99, 0xFF00B17C, 0xFFFE3300,
                                                    0xFFFF4314)
DEFINE_LAYER_BLEND_TEST(Luminosity, SkBlendMode::kLuminosity, 0xFF0099FF, 0xCC33FF99, 0xFF60BFFF,
                                                              0xFFFE3302, 0xFF2180C0)