tests/GrPorterDuffTest.cpp - Issue 1124373002: Implement Porter Duff XP with a blend table

Side by Side Diff: tests/GrPorterDuffTest.cpp

Issue 1124373002: Implement Porter Duff XP with a blend table (Closed) Base URL: https://skia.googlesource.com/skia.git@master

Patch Set: var names Created 5 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
(Empty)
	1 /*

	2 * Copyright 2015 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 "SkXfermode.h"

	9 #include "Test.h"

	10

	11 #if SK_SUPPORT_GPU

	12

	13 #include "GrContextFactory.h"

	14 #include "GrGpu.h"

	15 #include "GrXferProcessor.h"

	16 #include "effects/GrPorterDuffXferProcessor.h"

	17

	18 ////////////////////////////////////////////////////////////////////////////////

	19

	20 static void test_alpha_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);

	21 static void test_alpha_unknown_no_coverage(skiatest::Reporter* reporter, const G rCaps& caps);

	22 static void test_alpha_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);

	23 static void test_alpha_opaque_no_coverage(skiatest::Reporter* reporter, const Gr Caps& caps);

	24 static void test_color_white_with_coverage(skiatest::Reporter* reporter, const G rCaps& caps);

	25 static void test_color_white_no_coverage(skiatest::Reporter* reporter, const GrC aps& caps);

	26

	27 DEF_GPUTEST(GrPorterDuff, reporter, factory) {

	28 GrContext* ctx = factory->get(GrContextFactory::kNull_GLContextType);

	29 if (!ctx) {

	30 SkFAIL("Failed to create null context.");

	31 return;

	32 }

	33

	34 const GrCaps& caps = *ctx->getGpu()->caps();

	35 if (!caps.shaderCaps()->dualSourceBlendingSupport()) {

	36 SkFAIL("Null context does not support dual source blending.");

	37 return;

	38 }

	39

	40 test_alpha_unknown_with_coverage(reporter, caps);

	41 test_alpha_unknown_no_coverage(reporter, caps);

	42 test_alpha_opaque_with_coverage(reporter, caps);

	43 test_alpha_opaque_no_coverage(reporter, caps);

	44 test_color_white_with_coverage(reporter, caps);

	45 test_color_white_with_coverage(reporter, caps);

	46 test_color_white_no_coverage(reporter, caps);

	47 }

	48

	49 ////////////////////////////////////////////////////////////////////////////////

	50

	51 #define TEST_ASSERT(...) REPORTER_ASSERT(reporter, __VA_ARGS__)

	52

	53 enum {

	54 kNone_OutputType,

	55 kCoverage_OutputType,

	56 kModulate_OutputType,

	57 kISAModulate_OutputType,

	58 kISCModulate_OutputType

	59 };

	60

	61 enum {

	62 kNone_Opt = GrXferProcessor::kNone_Opt,

	63 kSkipDraw_OptFlag = GrXferProcessor::kSkipDraw_OptFlag,

	64 kIgnoreColor_OptFlag = GrXferProcessor::kIgnoreColor_OptFlag,

	65 kIgnoreCoverage_OptFlag = GrXferProcessor::kIgnoreCoverage_OptFlag,

	66 kCanTweakAlphaForCoverage_OptFlag = GrXferProcessor::kCanTweakAlphaForCovera ge_OptFlag

	67 };

	68

	69 struct XPInfo {

	70 XPInfo(skiatest::Reporter* reporter, SkXfermode::Mode xfermode, const GrCaps & caps,

	71 const GrProcOptInfo& colorPOI, const GrProcOptInfo& covPOI) {

	72 SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(xfermode));

	73 SkAutoTUnref<GrXferProcessor> xp(xpf->createXferProcessor(colorPOI, covP OI, 0, caps));

	74 TEST_ASSERT(!xpf->willNeedDstCopy(caps, colorPOI, covPOI));

	75 xpf->getInvariantOutput(colorPOI, covPOI, &fInvariantOutput);

	76 fOptFlags = xp->getOptimizations(colorPOI, covPOI, false, 0, caps);

	77 fPrimaryOutputType = GrPorterDuffXPFactory::TestGetXPOutputPrimay(xp);

	78 fSecondaryOutputType = GrPorterDuffXPFactory::TestGetXPOutputSecondary(x p);

	79 xp->getBlendInfo(&fBlendInfo);

	80 }

	81

	82 GrXPFactory::InvariantOutput fInvariantOutput;

	83 int fOptFlags;

	84 int fPrimaryOutputType;

	85 int fSecondaryOutputType;

	86 GrXferProcessor::BlendInfo fBlendInfo;

	87 };

	88

	89 static void test_alpha_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {

	90 GrProcOptInfo colorPOI, covPOI;

	91 colorPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, fals e);

	92 covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);

	93

	94 SkASSERT(!colorPOI.isOpaque());

	95 SkASSERT(!colorPOI.isSolidWhite());

	96 SkASSERT(!covPOI.isSolidWhite());

	97

	98 for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {

	99 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);

	100 const XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);

	101

	102 switch (xfermode) {

	103 case SkXfermode::kClear_Mode:

	104 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	105 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	106 TEST_ASSERT((kIgnoreColor_OptFlag) == xpi.fOptFlags);

	107 TEST_ASSERT(kCoverage_OutputType == xpi.fPrimaryOutputType);

	108 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	109 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.f Equation);

	110 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	111 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	112 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	113 break;

	114 case SkXfermode::kSrc_Mode:

	115 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	116 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	117 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	118 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	119 TEST_ASSERT(kCoverage_OutputType == xpi.fSecondaryOutputType);

	120 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	121 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	122 TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	123 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	124 break;

	125 case SkXfermode::kDst_Mode:

	126 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);
	Chris Dalton 2015/05/19 22:40:34 This one is confusing. Does "will blend with dst" This one is confusing. Does "will blend with dst" mean the final color output by the blend equation is dependent on the dst? (Meaning this value should be true for dst mode?) Or should "will blend with dst" be false for this xfer mode since it doesn't change anything? (The previous functionality was to set fWillBlendWithDst=true) egdaniel 2015/05/20 18:59:42 Yeah the intent is that Dst has an effect on the f Show quoted text On 2015/05/19 22:40:34, Chris Dalton wrote: > This one is confusing. Does "will blend with dst" mean the final color output by > the blend equation is dependent on the dst? (Meaning this value should be true > for dst mode?) Or should "will blend with dst" be false for this xfer mode since > it doesn't change anything? (The previous functionality was to set > fWillBlendWithDst=true) Yeah the intent is that Dst has an effect on the final color that is produced. Chris Dalton 2015/05/21 10:00:48 Ok that's kinda what I figured. Thanks for clarify Show quoted text On 2015/05/20 18:59:42, egdaniel wrote: > On 2015/05/19 22:40:34, Chris Dalton wrote: > > This one is confusing. Does "will blend with dst" mean the final color output > by > > the blend equation is dependent on the dst? (Meaning this value should be true > > for dst mode?) Or should "will blend with dst" be false for this xfer mode > since > > it doesn't change anything? (The previous functionality was to set > > fWillBlendWithDst=true) > > Yeah the intent is that Dst has an effect on the final color that is produced. Ok that's kinda what I figured. Thanks for clarifying.
	127 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	128 TEST_ASSERT((kSkipDraw_OptFlag \|

	129 kIgnoreColor_OptFlag \|

	130 kIgnoreCoverage_OptFlag \|

	131 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	132 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	133 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	134 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	135 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	136 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	137 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	138 break;

	139 case SkXfermode::kSrcOver_Mode:

	140 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	141 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	142 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	143 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	144 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	145 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	146 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	147 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	148 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	149 break;

	150 case SkXfermode::kDstOver_Mode:

	151 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	152 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	153 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	154 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	155 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	156 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	157 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	158 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	159 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	160 break;

	161 case SkXfermode::kSrcIn_Mode:

	162 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	163 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	164 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	165 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	166 TEST_ASSERT(kCoverage_OutputType == xpi.fSecondaryOutputType);

	167 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	168 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	169 TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	170 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	171 break;

	172 case SkXfermode::kDstIn_Mode:

	173 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	174 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	175 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	176 TEST_ASSERT(kISAModulate_OutputType == xpi.fPrimaryOutputType);

	177 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	178 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.f Equation);

	179 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	180 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	181 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	182 break;

	183 case SkXfermode::kSrcOut_Mode:

	184 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	185 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	186 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	187 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	188 TEST_ASSERT(kCoverage_OutputType == xpi.fSecondaryOutputType);

	189 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	190 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	191 TEST_ASSERT(kIS2A_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	192 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	193 break;

	194 case SkXfermode::kDstOut_Mode:

	195 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	196 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	197 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	198 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	199 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	200 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	201 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	202 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	203 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	204 break;

	205 case SkXfermode::kSrcATop_Mode:

	206 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	207 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	208 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	209 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	210 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	211 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	212 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	213 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	214 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	215 break;

	216 case SkXfermode::kDstATop_Mode:

	217 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	218 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	219 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	220 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	221 TEST_ASSERT(kISAModulate_OutputType == xpi.fSecondaryOutputType) ;

	222 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	223 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	224 TEST_ASSERT(kIS2C_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	225 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	226 break;

	227 case SkXfermode::kXor_Mode:

	228 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	229 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	230 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	231 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	232 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	233 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	234 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	235 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	236 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	237 break;

	238 case SkXfermode::kPlus_Mode:

	239 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	240 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	241 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	242 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	243 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	244 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	245 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	246 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	247 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	248 break;

	249 case SkXfermode::kModulate_Mode:

	250 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	251 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	252 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	253 TEST_ASSERT(kISCModulate_OutputType == xpi.fPrimaryOutputType);

	254 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	255 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.f Equation);

	256 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	257 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	258 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	259 break;

	260 case SkXfermode::kScreen_Mode:

	261 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	262 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	263 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	264 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	265 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	266 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	267 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	268 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	269 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	270 break;

	271 default:

	272 ERRORF(reporter, "Invalid xfermode.");

	273 break;

	274 }

	275 }

	276 }

	277

	278 static void test_alpha_unknown_no_coverage(skiatest::Reporter* reporter, const G rCaps& caps) {

	279 GrProcOptInfo colorPOI, covPOI;

	280 colorPOI.calcWithInitialValues(NULL, 0, GrColorPackRGBA(229, 0, 154, 0),

	281 kR_GrColorComponentFlag \| kB_GrColorComponent Flag, false);

	282 covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorCompo nentFlags, true);

	283

	284 SkASSERT(!colorPOI.isOpaque());

	285 SkASSERT(!colorPOI.isSolidWhite());

	286 SkASSERT(covPOI.isSolidWhite());

	287

	288 for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {

	289 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);

	290 const XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);

	291

	292 switch (xfermode) {

	293 case SkXfermode::kClear_Mode:

	294 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	295 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);

	296 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	297 TEST_ASSERT((kIgnoreColor_OptFlag \|

	298 kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	299 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	300 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	301 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	302 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	303 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	304 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	305 break;

	306 case SkXfermode::kSrc_Mode:

	307 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	308 TEST_ASSERT(229 == GrColorUnpackR(xpi.fInvariantOutput.fBlendedC olor));

	309 TEST_ASSERT(154 == GrColorUnpackB(xpi.fInvariantOutput.fBlendedC olor));

	310 TEST_ASSERT((kR_GrColorComponentFlag \|

	311 kB_GrColorComponentFlag) == xpi.fInvariantOutput.fB lendedColorFlags);

	312 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	313 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	314 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	315 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	316 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	317 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	318 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	319 break;

	320 case SkXfermode::kDst_Mode:

	321 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	322 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	323 TEST_ASSERT((kSkipDraw_OptFlag \|

	324 kIgnoreColor_OptFlag \|

	325 kIgnoreCoverage_OptFlag \|

	326 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	327 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	328 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	329 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	330 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	331 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	332 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	333 break;

	334 case SkXfermode::kSrcOver_Mode:

	335 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	336 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	337 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	338 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	339 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	340 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	341 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	342 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	343 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	344 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	345 break;

	346 case SkXfermode::kDstOver_Mode:

	347 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	348 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	349 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	350 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	351 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	352 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	353 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	354 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	355 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	356 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	357 break;

	358 case SkXfermode::kSrcIn_Mode:

	359 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	360 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	361 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	362 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	363 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	364 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	365 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	366 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	367 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	368 break;

	369 case SkXfermode::kDstIn_Mode:

	370 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	371 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	372 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	373 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	374 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	375 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	376 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	377 TEST_ASSERT(kSA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	378 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	379 break;

	380 case SkXfermode::kSrcOut_Mode:

	381 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	382 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	383 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	384 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	385 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	386 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	387 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	388 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	389 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	390 break;

	391 case SkXfermode::kDstOut_Mode:

	392 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	393 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	394 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	395 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	396 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	397 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	398 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	399 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	400 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	401 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	402 break;

	403 case SkXfermode::kSrcATop_Mode:

	404 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	405 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	406 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	407 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	408 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	409 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	410 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	411 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	412 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	413 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	414 break;

	415 case SkXfermode::kDstATop_Mode:

	416 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	417 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	418 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	419 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	420 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	421 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	422 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	423 TEST_ASSERT(kSA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	424 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	425 break;

	426 case SkXfermode::kXor_Mode:

	427 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	428 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	429 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	430 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	431 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	432 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	433 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	434 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	435 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	436 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	437 break;

	438 case SkXfermode::kPlus_Mode:

	439 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	440 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	441 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	442 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	443 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	444 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	445 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	446 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	447 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	448 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	449 break;

	450 case SkXfermode::kModulate_Mode:

	451 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	452 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	453 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	454 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	455 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	456 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	457 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	458 TEST_ASSERT(kSC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	459 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	460 break;

	461 case SkXfermode::kScreen_Mode:

	462 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	463 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	464 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	465 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	466 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	467 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	468 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	469 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	470 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	471 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	472 break;

	473 default:

	474 ERRORF(reporter, "Invalid xfermode.");

	475 break;

	476 }

	477 }

	478 }

	479

	480 static void test_alpha_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {

	481 GrProcOptInfo colorPOI, covPOI;

	482 colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kA_GrColorCompon entFlag, false);

	483 covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);

	484

	485 SkASSERT(colorPOI.isOpaque());

	486 SkASSERT(!colorPOI.isSolidWhite());

	487 SkASSERT(!covPOI.isSolidWhite());

	488

	489 for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {

	490 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);

	491 const XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);

	492

	493 switch (xfermode) {

	494 case SkXfermode::kClear_Mode:

	495 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	496 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	497 TEST_ASSERT((kIgnoreColor_OptFlag) == xpi.fOptFlags);

	498 TEST_ASSERT(kCoverage_OutputType == xpi.fPrimaryOutputType);

	499 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	500 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.f Equation);

	501 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	502 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	503 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	504 break;

	505 case SkXfermode::kSrc_Mode:

	506 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	507 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	508 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	509 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	510 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	511 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	512 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	513 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	514 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	515 break;

	516 case SkXfermode::kDst_Mode:

	517 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	518 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	519 TEST_ASSERT((kSkipDraw_OptFlag \|

	520 kIgnoreColor_OptFlag \|

	521 kIgnoreCoverage_OptFlag \|

	522 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	523 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	524 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	525 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	526 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	527 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	528 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	529 break;

	530 case SkXfermode::kSrcOver_Mode:

	531 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	532 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	533 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	534 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	535 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	536 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	537 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	538 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	539 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	540 break;

	541 case SkXfermode::kDstOver_Mode:

	542 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	543 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	544 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	545 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	546 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	547 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	548 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	549 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	550 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	551 break;

	552 case SkXfermode::kSrcIn_Mode:

	553 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	554 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	555 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	556 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	557 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	558 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	559 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	560 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	561 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	562 break;

	563 case SkXfermode::kDstIn_Mode:

	564 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	565 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	566 TEST_ASSERT((kSkipDraw_OptFlag \|

	567 kIgnoreColor_OptFlag \|

	568 kIgnoreCoverage_OptFlag \|

	569 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	570 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	571 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	572 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	573 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	574 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	575 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	576 break;

	577 case SkXfermode::kSrcOut_Mode:

	578 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	579 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	580 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	581 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	582 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	583 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	584 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	585 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	586 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	587 break;

	588 case SkXfermode::kDstOut_Mode:

	589 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	590 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	591 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	592 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	593 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	594 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	595 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	596 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	597 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	598 break;

	599 case SkXfermode::kSrcATop_Mode:

	600 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	601 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	602 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	603 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	604 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	605 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	606 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	607 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	608 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	609 break;

	610 case SkXfermode::kDstATop_Mode:

	611 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	612 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	613 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	614 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	615 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	616 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	617 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	618 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	619 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	620 break;

	621 case SkXfermode::kXor_Mode:

	622 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	623 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	624 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	625 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	626 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	627 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	628 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	629 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	630 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	631 break;

	632 case SkXfermode::kPlus_Mode:

	633 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	634 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	635 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	636 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	637 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	638 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	639 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	640 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	641 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	642 break;

	643 case SkXfermode::kModulate_Mode:

	644 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	645 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	646 TEST_ASSERT((kNone_Opt) == xpi.fOptFlags);

	647 TEST_ASSERT(kISCModulate_OutputType == xpi.fPrimaryOutputType);

	648 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	649 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.f Equation);

	650 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	651 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	652 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	653 break;

	654 case SkXfermode::kScreen_Mode:

	655 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	656 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	657 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	658 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	659 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	660 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	661 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	662 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	663 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	664 break;

	665 default:

	666 ERRORF(reporter, "Invalid xfermode.");

	667 break;

	668 }

	669 }

	670 }

	671

	672 static void test_alpha_opaque_no_coverage(skiatest::Reporter* reporter, const Gr Caps& caps) {

	673 GrProcOptInfo colorPOI, covPOI;

	674 colorPOI.calcWithInitialValues(NULL, 0, GrColorPackRGBA(0, 82, 0, 255),

	675 kG_GrColorComponentFlag \| kA_GrColorComponent Flag, false);

	676 covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorCompo nentFlags, true);

	677

	678 SkASSERT(colorPOI.isOpaque());

	679 SkASSERT(!colorPOI.isSolidWhite());

	680 SkASSERT(covPOI.isSolidWhite());

	681

	682 for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {

	683 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);

	684 const XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);

	685

	686 switch (xfermode) {

	687 case SkXfermode::kClear_Mode:

	688 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	689 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);

	690 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	691 TEST_ASSERT((kIgnoreColor_OptFlag \|

	692 kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	693 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	694 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	695 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	696 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	697 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	698 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	699 break;

	700 case SkXfermode::kSrc_Mode:

	701 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	702 TEST_ASSERT(82 == GrColorUnpackG(xpi.fInvariantOutput.fBlendedCo lor));

	703 TEST_ASSERT(255 == GrColorUnpackA(xpi.fInvariantOutput.fBlendedC olor));

	704 TEST_ASSERT((kG_GrColorComponentFlag \|

	705 kA_GrColorComponentFlag) == xpi.fInvariantOutput.fB lendedColorFlags);

	706 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	707 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	708 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	709 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	710 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	711 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	712 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	713 break;

	714 case SkXfermode::kDst_Mode:

	715 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	716 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	717 TEST_ASSERT((kSkipDraw_OptFlag \|

	718 kIgnoreColor_OptFlag \|

	719 kIgnoreCoverage_OptFlag \|

	720 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	721 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	722 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	723 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	724 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	725 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	726 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	727 break;

	728 case SkXfermode::kSrcOver_Mode:

	729 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	730 TEST_ASSERT(82 == GrColorUnpackG(xpi.fInvariantOutput.fBlendedCo lor));

	731 TEST_ASSERT(255 == GrColorUnpackA(xpi.fInvariantOutput.fBlendedC olor));

	732 TEST_ASSERT((kG_GrColorComponentFlag \|

	733 kA_GrColorComponentFlag) == xpi.fInvariantOutput.fB lendedColorFlags);

	734 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	735 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	736 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	737 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	738 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	739 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	740 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	741 break;

	742 case SkXfermode::kDstOver_Mode:

	743 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	744 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	745 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	746 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	747 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	748 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	749 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	750 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	751 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	752 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	753 break;

	754 case SkXfermode::kSrcIn_Mode:

	755 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	756 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	757 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	758 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	759 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	760 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	761 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	762 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	763 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	764 break;

	765 case SkXfermode::kDstIn_Mode:

	766 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	767 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	768 TEST_ASSERT((kSkipDraw_OptFlag \|

	769 kIgnoreColor_OptFlag \|

	770 kIgnoreCoverage_OptFlag \|

	771 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	772 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	773 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	774 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	775 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	776 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	777 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	778 break;

	779 case SkXfermode::kSrcOut_Mode:

	780 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	781 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	782 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	783 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	784 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	785 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	786 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	787 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	788 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	789 break;

	790 case SkXfermode::kDstOut_Mode:

	791 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	792 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);

	793 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	794 TEST_ASSERT((kIgnoreColor_OptFlag \|

	795 kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	796 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	797 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	798 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	799 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	800 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	801 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	802 break;

	803 case SkXfermode::kSrcATop_Mode:

	804 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	805 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	806 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	807 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	808 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	809 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	810 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	811 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	812 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	813 break;

	814 case SkXfermode::kDstATop_Mode:

	815 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	816 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	817 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	818 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	819 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	820 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	821 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	822 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	823 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	824 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	825 break;

	826 case SkXfermode::kXor_Mode:

	827 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	828 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	829 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	830 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	831 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	832 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	833 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	834 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	835 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	836 break;

	837 case SkXfermode::kPlus_Mode:

	838 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	839 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	840 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	841 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	842 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	843 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	844 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	845 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	846 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	847 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	848 break;

	849 case SkXfermode::kModulate_Mode:

	850 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	851 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	852 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	853 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	854 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	855 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	856 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	857 TEST_ASSERT(kSC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	858 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	859 break;

	860 case SkXfermode::kScreen_Mode:

	861 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	862 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	863 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	864 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	865 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	866 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	867 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	868 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	869 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	870 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	871 break;

	872 default:

	873 ERRORF(reporter, "Invalid xfermode.");

	874 break;

	875 }

	876 }

	877 }

	878

	879 static void test_color_white_with_coverage(skiatest::Reporter* reporter, const G rCaps& caps) {

	880 GrProcOptInfo colorPOI, covPOI;

	881 colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorCom ponentFlags, false);

	882 covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);

	883

	884 SkASSERT(colorPOI.isOpaque());

	885 SkASSERT(colorPOI.isSolidWhite());

	886 SkASSERT(!covPOI.isSolidWhite());

	887

	888 for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {

	889 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);

	890 const XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);

	891

	892 switch (xfermode) {

	893 case SkXfermode::kClear_Mode:

	894 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	895 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	896 TEST_ASSERT((kIgnoreColor_OptFlag) == xpi.fOptFlags);

	897 TEST_ASSERT(kCoverage_OutputType == xpi.fPrimaryOutputType);

	898 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	899 TEST_ASSERT(kReverseSubtract_GrBlendEquation == xpi.fBlendInfo.f Equation);

	900 TEST_ASSERT(kDC_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	901 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	902 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	903 break;

	904 case SkXfermode::kSrc_Mode:

	905 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	906 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	907 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	908 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	909 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	910 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	911 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	912 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	913 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	914 break;

	915 case SkXfermode::kDst_Mode:

	916 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	917 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	918 TEST_ASSERT((kSkipDraw_OptFlag \|

	919 kIgnoreColor_OptFlag \|

	920 kIgnoreCoverage_OptFlag \|

	921 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	922 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	923 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	924 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	925 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	926 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	927 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	928 break;

	929 case SkXfermode::kSrcOver_Mode:

	930 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	931 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	932 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	933 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	934 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	935 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	936 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	937 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	938 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	939 break;

	940 case SkXfermode::kDstOver_Mode:

	941 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	942 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	943 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	944 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	945 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	946 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	947 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	948 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	949 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	950 break;

	951 case SkXfermode::kSrcIn_Mode:

	952 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	953 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	954 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	955 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	956 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	957 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	958 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	959 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	960 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	961 break;

	962 case SkXfermode::kDstIn_Mode:

	963 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	964 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	965 TEST_ASSERT((kSkipDraw_OptFlag \|

	966 kIgnoreColor_OptFlag \|

	967 kIgnoreCoverage_OptFlag \|

	968 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	969 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	970 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	971 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	972 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	973 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	974 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	975 break;

	976 case SkXfermode::kSrcOut_Mode:

	977 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	978 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	979 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	980 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	981 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	982 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	983 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	984 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	985 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	986 break;

	987 case SkXfermode::kDstOut_Mode:

	988 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	989 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	990 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	991 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	992 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	993 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	994 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	995 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	996 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	997 break;

	998 case SkXfermode::kSrcATop_Mode:

	999 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1000 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1001 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1002 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1003 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1004 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1005 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1006 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1007 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1008 break;

	1009 case SkXfermode::kDstATop_Mode:

	1010 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1011 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1012 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1013 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1014 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1015 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1016 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1017 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1018 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1019 break;

	1020 case SkXfermode::kXor_Mode:

	1021 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1022 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1023 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1024 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1025 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1026 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1027 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1028 TEST_ASSERT(kISA_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1029 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1030 break;

	1031 case SkXfermode::kPlus_Mode:

	1032 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1033 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1034 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1035 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1036 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1037 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1038 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1039 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1040 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1041 break;

	1042 case SkXfermode::kModulate_Mode:

	1043 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1044 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1045 TEST_ASSERT((kSkipDraw_OptFlag \|

	1046 kIgnoreColor_OptFlag \|

	1047 kIgnoreCoverage_OptFlag \|

	1048 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1049 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	1050 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1051 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1052 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1053 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1054 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	1055 break;

	1056 case SkXfermode::kScreen_Mode:

	1057 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1058 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1059 TEST_ASSERT((kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1060 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1061 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1062 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1063 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1064 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1065 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1066 break;

	1067 default:

	1068 ERRORF(reporter, "Invalid xfermode.");

	1069 break;

	1070 }

	1071 }

	1072 }

	1073

	1074 static void test_color_white_no_coverage(skiatest::Reporter* reporter, const GrC aps& caps) {

	1075 GrProcOptInfo colorPOI, covPOI;

	1076 colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorCom ponentFlags, false);

	1077 covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorCompo nentFlags, true);

	1078

	1079 SkASSERT(colorPOI.isOpaque());

	1080 SkASSERT(colorPOI.isSolidWhite());

	1081 SkASSERT(covPOI.isSolidWhite());

	1082

	1083 for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {

	1084 SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);

	1085 const XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);

	1086

	1087 switch (xfermode) {

	1088 case SkXfermode::kClear_Mode:

	1089 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	1090 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);

	1091 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1092 TEST_ASSERT((kIgnoreColor_OptFlag \|

	1093 kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1094 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	1095 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1096 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1097 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1098 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1099 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1100 break;

	1101 case SkXfermode::kSrc_Mode:

	1102 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	1103 TEST_ASSERT(GrColorPackA4(255) == xpi.fInvariantOutput.fBlendedC olor);

	1104 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1105 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1106 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1107 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1108 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1109 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1110 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1111 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1112 break;

	1113 case SkXfermode::kDst_Mode:

	1114 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1115 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1116 TEST_ASSERT((kSkipDraw_OptFlag \|

	1117 kIgnoreColor_OptFlag \|

	1118 kIgnoreCoverage_OptFlag \|

	1119 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1120 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	1121 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1122 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1123 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1124 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1125 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	1126 break;

	1127 case SkXfermode::kSrcOver_Mode:

	1128 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	1129 TEST_ASSERT(GrColorPackA4(255) == xpi.fInvariantOutput.fBlendedC olor);

	1130 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1131 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1132 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1133 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1134 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1135 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1136 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1137 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1138 break;

	1139 case SkXfermode::kDstOver_Mode:

	1140 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1141 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1142 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	1143 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1144 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1145 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1146 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1147 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1148 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1149 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1150 break;

	1151 case SkXfermode::kSrcIn_Mode:

	1152 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1153 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1154 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1155 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1156 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1157 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1158 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1159 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1160 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1161 break;

	1162 case SkXfermode::kDstIn_Mode:

	1163 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1164 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1165 TEST_ASSERT((kSkipDraw_OptFlag \|

	1166 kIgnoreColor_OptFlag \|

	1167 kIgnoreCoverage_OptFlag \|

	1168 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1169 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	1170 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1171 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1172 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1173 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1174 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	1175 break;

	1176 case SkXfermode::kSrcOut_Mode:

	1177 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1178 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1179 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1180 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1181 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1182 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1183 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1184 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1185 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1186 break;

	1187 case SkXfermode::kDstOut_Mode:

	1188 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	1189 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);

	1190 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1191 TEST_ASSERT((kIgnoreColor_OptFlag \|

	1192 kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1193 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	1194 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1195 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1196 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1197 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1198 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1199 break;

	1200 case SkXfermode::kSrcATop_Mode:

	1201 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1202 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1203 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1204 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1205 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1206 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1207 TEST_ASSERT(kDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1208 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1209 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1210 break;

	1211 case SkXfermode::kDstATop_Mode:

	1212 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1213 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1214 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	1215 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1216 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1217 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1218 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1219 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1220 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1221 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1222 break;

	1223 case SkXfermode::kXor_Mode:

	1224 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1225 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1226 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1227 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1228 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1229 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1230 TEST_ASSERT(kIDA_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1231 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1232 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1233 break;

	1234 case SkXfermode::kPlus_Mode:

	1235 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1236 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1237 TEST_ASSERT((kIgnoreCoverage_OptFlag \|

	1238 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1239 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1240 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1241 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1242 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1243 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1244 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1245 break;

	1246 case SkXfermode::kModulate_Mode:

	1247 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);

	1248 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1249 TEST_ASSERT((kSkipDraw_OptFlag \|

	1250 kIgnoreColor_OptFlag \|

	1251 kIgnoreCoverage_OptFlag \|

	1252 kCanTweakAlphaForCoverage_OptFlag) == xpi.fOptFlags );

	1253 TEST_ASSERT(kNone_OutputType == xpi.fPrimaryOutputType);

	1254 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1255 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1256 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1257 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1258 TEST_ASSERT(!xpi.fBlendInfo.fWriteColor);

	1259 break;

	1260 case SkXfermode::kScreen_Mode:

	1261 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);

	1262 TEST_ASSERT(GrColorPackA4(255) == xpi.fInvariantOutput.fBlendedC olor);

	1263 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput. fBlendedColorFlags);

	1264 TEST_ASSERT((kIgnoreCoverage_OptFlag) == xpi.fOptFlags);

	1265 TEST_ASSERT(kModulate_OutputType == xpi.fPrimaryOutputType);

	1266 TEST_ASSERT(kNone_OutputType == xpi.fSecondaryOutputType);

	1267 TEST_ASSERT(kAdd_GrBlendEquation == xpi.fBlendInfo.fEquation);

	1268 TEST_ASSERT(kOne_GrBlendCoeff == xpi.fBlendInfo.fSrcBlend);

	1269 TEST_ASSERT(kZero_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);

	1270 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);

	1271 break;

	1272 default:

	1273 ERRORF(reporter, "Invalid xfermode.");

	1274 break;

	1275 }

	1276 }

	1277 }

	1278

	1279 #endif

	1280

OLD	NEW

« src/gpu/effects/GrPorterDuffXferProcessor.cpp ('K') | « src/gpu/effects/GrPorterDuffXferProcessor.cpp ('k') | no next file » | no next file with comments »