Enable blend optimizations with instanced draws

src/gpu/instanced/InstancedRendering.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "InstancedRendering.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 310 matching lines @@
 
 void InstancedRendering::Batch::appendParamsTexel(SkScalar x, SkScalar y, SkScalar z) {
     SkASSERT(!fIsTracked);
     ParamsTexel& texel = fParams.push_back();
     texel.fX = SkScalarToFloat(x);
     texel.fY = SkScalarToFloat(y);
     texel.fZ = SkScalarToFloat(z);
     fInfo.fHasParams = true;
 }
 
+void InstancedRendering::Batch::computePipelineOptimizations(GrInitInvariantOutput* color,
+                                                            GrInitInvariantOutput* coverage,
+                                                            GrBatchToXPOverrides* overrides) const {
+    color->setKnownFourComponents(this->getSingleInstance().fColor);
+
+    if (AntialiasMode::kCoverage == fInfo.fAntialiasMode ||
+        (AntialiasMode::kNone == fInfo.fAntialiasMode &&
+         !fInfo.isSimpleRects() && fInfo.fCannotDiscard)) {
+        coverage->setUnknownSingleComponent();
+    } else {
+        coverage->setKnownSingleComponent(255);
+    }
+}
+
 void InstancedRendering::Batch::initBatchTracker(const GrXPOverridesForBatch& overrides) {
     Draw& draw = this->getSingleDraw(); // This will assert if we have > 1 command.
     SkASSERT(draw.fGeometry.isEmpty());
     SkASSERT(SkIsPow2(fInfo.fShapeTypes));
     SkASSERT(!fIsTracked);
 
     if (kRect_ShapeFlag == fInfo.fShapeTypes) {
         draw.fGeometry = InstanceProcessor::GetIndexRangeForRect(fInfo.fAntialiasMode);
     } else if (kOval_ShapeFlag == fInfo.fShapeTypes) {
         draw.fGeometry = InstanceProcessor::GetIndexRangeForOval(fInfo.fAntialiasMode, fBounds);
@@ skipping 41 matching lines @@
         ++fNumChangesInGeometry;
     }
     fTailDraw->fNext = that->fHeadDraw;
     fTailDraw = that->fTailDraw;
 
     that->fHeadDraw = that->fTailDraw = nullptr;
 
     return true;
 }
 
-void InstancedRendering::Batch::computePipelineOptimizations(GrInitInvariantOutput* color,
-                                                            GrInitInvariantOutput* coverage,
-                                                            GrBatchToXPOverrides* overrides) const {
-    // We need to be careful about fInfo here and consider how it might change as batches combine.
-    // e.g. We can't make an assumption based on fInfo.isSimpleRects() because the batch might
-    // later combine with a non-rect.

[csmartdalton, 2016/07/03 17:36:43]

This comment was actually just about a bug, fixed here:
https://codereview.chromium.org/2120153002/

-    color->setUnknownFourComponents();
-    if (fInfo.fAntialiasMode >= AntialiasMode::kMSAA) {
-        coverage->setKnownSingleComponent(255);
-    } else if (AntialiasMode::kNone == fInfo.fAntialiasMode && !fInfo.fCannotDiscard) {
-        coverage->setKnownSingleComponent(255);
-    } else {
-        coverage->setUnknownSingleComponent();
-    }
-}
-
 void InstancedRendering::beginFlush(GrResourceProvider* rp) {
     SkASSERT(State::kRecordingDraws == fState);
     fState = State::kFlushing;
 
     if (fTrackedBatches.isEmpty()) {
         return;
     }
 
     if (!fVertexBuffer) {
         fVertexBuffer.reset(InstanceProcessor::FindOrCreateVertexBuffer(fGpu));
@@ skipping 47 matching lines @@
 }
 
 void InstancedRendering::resetGpuResources(ResetType resetType) {
     fVertexBuffer.reset();
     fIndexBuffer.reset();
     fParamsBuffer.reset();
     this->onResetGpuResources(resetType);
 }
 
 }