Relandx2 "Remove antialiasing control from GrPaint."

Fixes a bad merge.

This reverts commit 073285c0595d46205d1482cc19af2d7d891bfeae.

Change-Id: I5e92339d9b33d3a6dc58b9fcd2a1b3a5684e8f8a
Reviewed-on: https://skia-review.googlesource.com/5774
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

3 files changed, 46 insertions, 49 deletions

diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp
index 135a0610ad..faecfe5eed 100644
--- a/src/gpu/instanced/InstancedRendering.cpp
+++ b/src/gpu/instanced/InstancedRendering.cpp
@@ -22,28 +22,27 @@ InstancedRendering::InstancedRendering(GrGpu* gpu)
 }
 
 GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
-                                         GrColor color, bool antialias,
-                                         const GrInstancedPipelineInfo& info, bool* useHWAA) {
-    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias, info,
-                             useHWAA);
+                                         GrColor color, GrAA aa,
+                                         const GrInstancedPipelineInfo& info, GrAAType* aaType) {
+    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, aa, info, aaType);
 }
 
 GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
-                                         GrColor color, const SkRect& localRect, bool antialias,
-                                         const GrInstancedPipelineInfo& info, bool* useHWAA) {
-    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, localRect, antialias, info,
-                             useHWAA);
+                                         GrColor color, const SkRect& localRect, GrAA aa,
+                                         const GrInstancedPipelineInfo& info, GrAAType* aaType) {
+    return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, localRect, aa, info,
+                             aaType);
 }
 
 GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
                                          GrColor color, const SkMatrix& localMatrix,
-                                         bool antialias, const GrInstancedPipelineInfo& info,
-                                         bool* useHWAA) {
+                                         GrAA aa, const GrInstancedPipelineInfo& info,
+                                         GrAAType* aaType) {
     if (localMatrix.hasPerspective()) {
         return nullptr; // Perspective is not yet supported in the local matrix.
     }
-    if (Batch* batch = this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias,
-                                         info, useHWAA)) {
+    if (Batch* batch = this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, aa,
+                                         info, aaType)) {
         batch->getSingleInstance().fInfo |= kLocalMatrix_InfoFlag;
         batch->appendParamsTexel(localMatrix.getScaleX(), localMatrix.getSkewX(),
                                  localMatrix.getTranslateX());
@@ -56,17 +55,16 @@ GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& vie
 }
 
 GrDrawOp* InstancedRendering::recordOval(const SkRect& oval, const SkMatrix& viewMatrix,
-                                         GrColor color, bool antialias,
-                                         const GrInstancedPipelineInfo& info, bool* useHWAA) {
-    return this->recordShape(ShapeType::kOval, oval, viewMatrix, color, oval, antialias, info,
-                             useHWAA);
+                                         GrColor color, GrAA aa,
+                                         const GrInstancedPipelineInfo& info, GrAAType* aaType) {
+    return this->recordShape(ShapeType::kOval, oval, viewMatrix, color, oval, aa, info, aaType);
 }
 
 GrDrawOp* InstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix& viewMatrix,
-                                          GrColor color, bool antialias,
-                                          const GrInstancedPipelineInfo& info, bool* useHWAA) {
+                                          GrColor color, GrAA aa,
+                                          const GrInstancedPipelineInfo& info, GrAAType* aaType) {
     if (Batch* batch = this->recordShape(GetRRectShapeType(rrect), rrect.rect(), viewMatrix, color,
-                                         rrect.rect(), antialias, info, useHWAA)) {
+                                         rrect.rect(), aa, info, aaType)) {
         batch->appendRRectParams(rrect);
         return batch;
     }
@@ -75,16 +73,16 @@ GrDrawOp* InstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix&
 
 GrDrawOp* InstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect& inner,
                                            const SkMatrix& viewMatrix, GrColor color,
-                                           bool antialias, const GrInstancedPipelineInfo& info,
-                                           bool* useHWAA) {
+                                           GrAA aa, const GrInstancedPipelineInfo& info,
+                                           GrAAType* aaType) {
     if (inner.getType() > SkRRect::kSimple_Type) {
        return nullptr; // Complex inner round rects are not yet supported.
     }
     if (SkRRect::kEmpty_Type == inner.getType()) {
-        return this->recordRRect(outer, viewMatrix, color, antialias, info, useHWAA);
+        return this->recordRRect(outer, viewMatrix, color, aa, info, aaType);
     }
     if (Batch* batch = this->recordShape(GetRRectShapeType(outer), outer.rect(), viewMatrix, color,
-                                         outer.rect(), antialias, info, useHWAA)) {
+                                         outer.rect(), aa, info, aaType)) {
         batch->appendRRectParams(outer);
         ShapeType innerShapeType = GetRRectShapeType(inner);
         batch->fInfo.fInnerShapeTypes |= GetShapeFlag(innerShapeType);
@@ -99,9 +97,9 @@ GrDrawOp* InstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect&
 InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const SkRect& bounds,
                                                            const SkMatrix& viewMatrix,
                                                            GrColor color, const SkRect& localRect,
-                                                           bool antialias,
+                                                           GrAA aa,
                                                            const GrInstancedPipelineInfo& info,
-                                                           bool* useHWAA) {
+                                                           GrAAType* aaType) {
     SkASSERT(State::kRecordingDraws == fState);
 
     if (info.fIsRenderingToFloat && fGpu->caps()->avoidInstancedDrawsToFPTargets()) {
@@ -109,7 +107,7 @@ InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const
     }
 
     AntialiasMode antialiasMode;
-    if (!this->selectAntialiasMode(viewMatrix, antialias, info, useHWAA, &antialiasMode)) {
+    if (!this->selectAntialiasMode(viewMatrix, aa, info, aaType, &antialiasMode)) {
         return nullptr;
     }
 
@@ -193,27 +191,28 @@ InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const
     return batch;
 }
 
-inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
+inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, GrAA aa,
                                                     const GrInstancedPipelineInfo& info,
-                                                    bool* useHWAA, AntialiasMode* antialiasMode) {
+                                                    GrAAType* aaType,
+                                                    AntialiasMode* antialiasMode) {
     SkASSERT(!info.fColorDisabled || info.fDrawingShapeToStencil);
     SkASSERT(!info.fIsMixedSampled || info.fIsMultisampled);
     SkASSERT(GrCaps::InstancedSupport::kNone != fGpu->caps()->instancedSupport());
 
     if (!info.fIsMultisampled || fGpu->caps()->multisampleDisableSupport()) {
-        if (!antialias) {
+        if (GrAA::kNo == aa) {
             if (info.fDrawingShapeToStencil && !info.fCanDiscard) {
                 // We can't draw to the stencil buffer without discard (or sample mask if MSAA).
                 return false;
             }
             *antialiasMode = AntialiasMode::kNone;
-            *useHWAA = false;
+            *aaType = GrAAType::kNone;
             return true;
         }
 
         if (info.canUseCoverageAA() && viewMatrix.preservesRightAngles()) {
             *antialiasMode = AntialiasMode::kCoverage;
-            *useHWAA = false;
+            *aaType = GrAAType::kCoverage;
             return true;
         }
     }
@@ -222,12 +221,12 @@ inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix,
         fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMultisampled) {
         if (!info.fIsMixedSampled || info.fColorDisabled) {
             *antialiasMode = AntialiasMode::kMSAA;
-            *useHWAA = true;
+            *aaType = GrAAType::kMSAA;
             return true;
         }
         if (fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMixedSampled) {
             *antialiasMode = AntialiasMode::kMixedSamples;
-            *useHWAA = true;
+            *aaType = GrAAType::kMixedSamples;
             return true;
         }
     }
diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h
index d3a01523a6..903697436c 100644
--- a/src/gpu/instanced/InstancedRendering.h
+++ b/src/gpu/instanced/InstancedRendering.h
@@ -46,28 +46,25 @@ public:
      * draws between beginFlush() and endFlush().
      */
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor,
-                                               bool antialias, const GrInstancedPipelineInfo&,
-                                               bool* useHWAA);
+                                               GrAA, const GrInstancedPipelineInfo&, GrAAType*);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor,
-                                               const SkRect& localRect, bool antialias,
-                                               const GrInstancedPipelineInfo&, bool* useHWAA);
+                                               const SkRect& localRect, GrAA,
+                                               const GrInstancedPipelineInfo&, GrAAType*);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor,
-                                               const SkMatrix& localMatrix, bool antialias,
-                                               const GrInstancedPipelineInfo&, bool* useHWAA);
+                                               const SkMatrix& localMatrix, GrAA,
+                                               const GrInstancedPipelineInfo&, GrAAType*);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordOval(const SkRect&, const SkMatrix&, GrColor,
-                                               bool antialias, const GrInstancedPipelineInfo&,
-                                               bool* useHWAA);
+                                               GrAA, const GrInstancedPipelineInfo&, GrAAType*);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordRRect(const SkRRect&, const SkMatrix&, GrColor,
-                                                bool antialias, const GrInstancedPipelineInfo&,
-                                                bool* useHWAA);
+                                                GrAA, const GrInstancedPipelineInfo&, GrAAType*);
 
     GrDrawOp* SK_WARN_UNUSED_RESULT recordDRRect(const SkRRect& outer, const SkRRect& inner,
-                                                 const SkMatrix&, GrColor, bool antialias,
-                                                 const GrInstancedPipelineInfo&, bool* useHWAA);
+                                                 const SkMatrix&, GrColor, GrAA,
+                                                 const GrInstancedPipelineInfo&, GrAAType*);
 
     /**
      * Compiles all recorded draws into GPU buffers and allows the client to begin flushing the
@@ -182,11 +179,11 @@ private:
 
     Batch* SK_WARN_UNUSED_RESULT recordShape(ShapeType, const SkRect& bounds,
                                              const SkMatrix& viewMatrix, GrColor,
-                                             const SkRect& localRect, bool antialias,
-                                             const GrInstancedPipelineInfo&, bool* requireHWAA);
+                                             const SkRect& localRect, GrAA aa,
+                                             const GrInstancedPipelineInfo&, GrAAType*);
 
-    bool selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
-                             const GrInstancedPipelineInfo&, bool* useHWAA, AntialiasMode*);
+    bool selectAntialiasMode(const SkMatrix& viewMatrix, GrAA aa, const GrInstancedPipelineInfo&,
+                             GrAAType*, AntialiasMode*);
 
     virtual Batch* createBatch() = 0;
 
diff --git a/src/gpu/instanced/InstancedRenderingTypes.h b/src/gpu/instanced/InstancedRenderingTypes.h
index 97f8946d03..2ed269a8cf 100644
--- a/src/gpu/instanced/InstancedRenderingTypes.h
+++ b/src/gpu/instanced/InstancedRenderingTypes.h
@@ -42,6 +42,7 @@ enum class Attrib : uint8_t {
 };
 constexpr int kNumAttribs = 1 + (int)Attrib::kLocalRect;
 
+// TODO: replace with GrAAType?
 enum class AntialiasMode : uint8_t {
     kNone,
     kCoverage,