Fix LCD coverage regression in GrPorterDuffXPFactory

tests/GrPorterDuffTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkXfermode.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 
+#include "GrBatch.h"
 #include "GrContextFactory.h"
 #include "GrGpu.h"
 #include "GrXferProcessor.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static void test_alpha_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
 static void test_alpha_unknown_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
 static void test_alpha_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
 static void test_alpha_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
 static void test_color_white_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
 static void test_color_white_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
+static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps);
 
 DEF_GPUTEST(GrPorterDuff, reporter, factory) {
     GrContext* ctx = factory->get(GrContextFactory::kNull_GLContextType);
     if (!ctx) {
         SkFAIL("Failed to create null context.");
         return;
     }
 
     const GrCaps& caps = *ctx->getGpu()->caps();
     if (!caps.shaderCaps()->dualSourceBlendingSupport()) {
         SkFAIL("Null context does not support dual source blending.");
         return;
     }
 
     test_alpha_unknown_with_coverage(reporter, caps);
     test_alpha_unknown_no_coverage(reporter, caps);
     test_alpha_opaque_with_coverage(reporter, caps);
     test_alpha_opaque_no_coverage(reporter, caps);
     test_color_white_with_coverage(reporter, caps);
     test_color_white_with_coverage(reporter, caps);
     test_color_white_no_coverage(reporter, caps);
+    test_lcd_coverage(reporter, caps);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define TEST_ASSERT(...) REPORTER_ASSERT(reporter, __VA_ARGS__)
 
 enum {
     kNone_OutputType,
     kCoverage_OutputType,
     kModulate_OutputType,
@@ skipping 36 matching lines @@
 };
 
 static void test_alpha_unknown_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
     colorPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, false);
     covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);
 
     SkASSERT(!colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(!covPOI.isSolidWhite());
+    SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
         switch (xfermode) {
             case SkXfermode::kClear_Mode:
                 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);
                 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput.fBlendedColorFlags);
                 TEST_ASSERT((kIgnoreColor_OptFlag) == xpi.fOptFlags);
@@ skipping 170 matching lines @@
 
 static void test_alpha_unknown_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
     colorPOI.calcWithInitialValues(NULL, 0, GrColorPackRGBA(229, 0, 154, 0),
                                    kR_GrColorComponentFlag | kB_GrColorComponentFlag, false);
     covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
 
     SkASSERT(!colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(covPOI.isSolidWhite());
+    SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
         switch (xfermode) {
             case SkXfermode::kClear_Mode:
                 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);
                 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);
                 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput.fBlendedColorFlags);
@@ skipping 181 matching lines @@
 }
 
 static void test_alpha_opaque_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
     colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kA_GrColorComponentFlag, false);
     covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);
 
     SkASSERT(colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(!covPOI.isSolidWhite());
+    SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
         switch (xfermode) {
             case SkXfermode::kClear_Mode:
                 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);
                 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput.fBlendedColorFlags);
                 TEST_ASSERT((kIgnoreColor_OptFlag) == xpi.fOptFlags);
@@ skipping 173 matching lines @@
 
 static void test_alpha_opaque_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
     colorPOI.calcWithInitialValues(NULL, 0, GrColorPackRGBA(0, 82, 0, 255),
                                    kG_GrColorComponentFlag | kA_GrColorComponentFlag, false);
     covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
 
     SkASSERT(colorPOI.isOpaque());
     SkASSERT(!colorPOI.isSolidWhite());
     SkASSERT(covPOI.isSolidWhite());
+    SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
         switch (xfermode) {
             case SkXfermode::kClear_Mode:
                 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);
                 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);
                 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput.fBlendedColorFlags);
@@ skipping 186 matching lines @@
 }
 
 static void test_color_white_with_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
     colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, false);
     covPOI.calcWithInitialValues(NULL, 0, 0, kNone_GrColorComponentFlags, true);
 
     SkASSERT(colorPOI.isOpaque());
     SkASSERT(colorPOI.isSolidWhite());
     SkASSERT(!covPOI.isSolidWhite());
+    SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
         switch (xfermode) {
             case SkXfermode::kClear_Mode:
                 TEST_ASSERT(xpi.fInvariantOutput.fWillBlendWithDst);
                 TEST_ASSERT(kNone_GrColorComponentFlags == xpi.fInvariantOutput.fBlendedColorFlags);
                 TEST_ASSERT((kIgnoreColor_OptFlag) == xpi.fOptFlags);
@@ skipping 172 matching lines @@
 }
 
 static void test_color_white_no_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
     GrProcOptInfo colorPOI, covPOI;
     colorPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, false);
     covPOI.calcWithInitialValues(NULL, 0, GrColorPackA4(255), kRGBA_GrColorComponentFlags, true);
 
     SkASSERT(colorPOI.isOpaque());
     SkASSERT(colorPOI.isSolidWhite());
     SkASSERT(covPOI.isSolidWhite());
+    SkASSERT(!covPOI.isFourChannelOutput());
 
     for (int m = 0; m <= SkXfermode::kLastCoeffMode; m++) {
         SkXfermode::Mode xfermode = static_cast<SkXfermode::Mode>(m);
         const GrPorterDuffTest::XPInfo xpi(reporter, xfermode, caps, colorPOI, covPOI);
 
         switch (xfermode) {
             case SkXfermode::kClear_Mode:
                 TEST_ASSERT(!xpi.fInvariantOutput.fWillBlendWithDst);
                 TEST_ASSERT(0 == xpi.fInvariantOutput.fBlendedColor);
                 TEST_ASSERT(kRGBA_GrColorComponentFlags == xpi.fInvariantOutput.fBlendedColorFlags);
@@ skipping 174 matching lines @@
                 TEST_ASSERT(kISC_GrBlendCoeff == xpi.fBlendInfo.fDstBlend);
                 TEST_ASSERT(xpi.fBlendInfo.fWriteColor);
                 break;
             default:
                 ERRORF(reporter, "Invalid xfermode.");
                 break;
         }
     }
 }
 
+static void test_lcd_coverage(skiatest::Reporter* reporter, const GrCaps& caps) {
+    class : public GrBatch {
+        void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
+            out->setKnownFourComponents(GrColorPackRGBA(123, 45, 67, 221));
+        }
+
+        void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
+            out->setUnknownFourComponents();
+            out->setUsingLCDCoverage();
+        }
+
+        const char* name() const override { return "Test LCD Text Batch"; }
+        void initBatchTracker(const GrPipelineInfo&) override {}
+        bool onCombineIfPossible(GrBatch*) override  { return false; }
+        void generateGeometry(GrBatchTarget*, const GrPipeline*) override {}
+
+    } testLCDCoverageBatch;
+
+    GrProcOptInfo colorPOI, covPOI;
+    colorPOI.calcColorWithBatch(&testLCDCoverageBatch, NULL, 0);
+    covPOI.calcCoverageWithBatch(&testLCDCoverageBatch, NULL, 0);
+
+    SkASSERT(kRGBA_GrColorComponentFlags == colorPOI.validFlags());
+    SkASSERT(covPOI.isFourChannelOutput());
+
+    SkAutoTUnref<GrXPFactory> xpf(GrPorterDuffXPFactory::Create(SkXfermode::kSrcOver_Mode));
+    TEST_ASSERT(!xpf->willNeedDstCopy(caps, colorPOI, covPOI));
+
+    GrXPFactory::InvariantOutput invariantOutput;
+    xpf->getInvariantOutput(colorPOI, covPOI, &invariantOutput);
+    TEST_ASSERT(invariantOutput.fWillBlendWithDst);
+    TEST_ASSERT(kNone_GrColorComponentFlags == invariantOutput.fBlendedColorFlags);
+
+    SkAutoTUnref<GrXferProcessor> xp(xpf->createXferProcessor(colorPOI, covPOI, 0, caps));
+    if (!xp) {
+        ERRORF(reporter, "Failed to create an XP with LCD coverage.");
+        return;
+    }
+
+    GrColor overrideColor;
+    xp->getOptimizations(colorPOI, covPOI, false, &overrideColor, caps);
+
+    GrXferProcessor::BlendInfo blendInfo;
+    xp->getBlendInfo(&blendInfo);
+    TEST_ASSERT(blendInfo.fWriteColor);
+}
+
 #endif