Small cleanups after GrDrawState/GrOptDrawState base class elimination.

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 
 #include "GrBlend.h"
@@ skipping 176 matching lines @@
     }
 
     this->setRenderTarget(rt);
 
     fViewMatrix = vm;
 
     // These have no equivalent in GrPaint, set them to defaults
     fBlendConstant = 0x0;
     fDrawFace = kBoth_DrawFace;
     fStencilSettings.setDisabled();
-    this->resetStateFlags();
+    fFlagBits = 0;
     fHints = 0;
 
     // Enable the clip bit
     this->enableState(GrDrawState::kClip_StateBit);
 
     this->setColor(paint.getColor());
     this->setState(GrDrawState::kDither_StateBit, paint.isDither());
     this->setState(GrDrawState::kHWAntialias_StateBit, paint.isAntiAlias());
 
     this->setBlendFunc(paint.getSrcBlendCoeff(), paint.getDstBlendCoeff());
@@ skipping 126 matching lines @@
 
 bool GrDrawState::couldApplyCoverage(const GrDrawTargetCaps& caps) const {
     if (caps.dualSourceBlendingSupport()) {
         return true;
     }
     // we can correctly apply coverage if a) we have dual source blending
     // or b) one of our blend optimizations applies
     // or c) the src, dst blend coeffs are 1,0 and we will read Dst Color
     GrBlendCoeff srcCoeff;
     GrBlendCoeff dstCoeff;
-    BlendOptFlags flag = this->getBlendOpts(true, &srcCoeff, &dstCoeff);
-    return GrDrawState::kNone_BlendOpt != flag ||
+    BlendOpt opt = this->getBlendOpt(true, &srcCoeff, &dstCoeff);
+    return GrDrawState::kNone_BlendOpt != opt ||
            (this->willEffectReadDstColor() &&
             kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff);
 }
 
 bool GrDrawState::hasSolidCoverage() const {
     // If we're drawing coverage directly then coverage is effectively treated as color.
     if (this->isCoverageDrawing()) {
         return true;
     }
 
@@ skipping 175 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawState::~GrDrawState() {
     SkASSERT(0 == fBlockEffectRemovalCnt);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-GrDrawState::BlendOptFlags GrDrawState::getBlendOpts(bool forceCoverage,
-                                                     GrBlendCoeff* srcCoeff,
-                                                     GrBlendCoeff* dstCoeff) const {
+GrDrawState::BlendOpt GrDrawState::getBlendOpt(bool forceCoverage,
+                                               GrBlendCoeff* srcCoeff,
+                                               GrBlendCoeff* dstCoeff) const {
     GrBlendCoeff bogusSrcCoeff, bogusDstCoeff;
     if (NULL == srcCoeff) {
         srcCoeff = &bogusSrcCoeff;
     }
     if (NULL == dstCoeff) {
         dstCoeff = &bogusDstCoeff;
     }
 
     *srcCoeff = this->getSrcBlendCoeff();
     *dstCoeff = this->getDstBlendCoeff();
 
     if (this->isColorWriteDisabled()) {
         *srcCoeff = kZero_GrBlendCoeff;
         *dstCoeff = kOne_GrBlendCoeff;
     }
 
     bool srcAIsOne = this->srcAlphaWillBeOne();
     bool dstCoeffIsOne = kOne_GrBlendCoeff == *dstCoeff ||
                          (kSA_GrBlendCoeff == *dstCoeff && srcAIsOne);
     bool dstCoeffIsZero = kZero_GrBlendCoeff == *dstCoeff ||
                          (kISA_GrBlendCoeff == *dstCoeff && srcAIsOne);
 
     // When coeffs are (0,1) there is no reason to draw at all, unless
     // stenciling is enabled. Having color writes disabled is effectively
     // (0,1).
     if ((kZero_GrBlendCoeff == *srcCoeff && dstCoeffIsOne)) {
         if (this->getStencil().doesWrite()) {
-            return kEmitCoverage_BlendOptFlag;
+            return kEmitCoverage_BlendOpt;
         } else {
             *dstCoeff = kOne_GrBlendCoeff;
-            return kSkipDraw_BlendOptFlag;
+            return kSkipDraw_BlendOpt;
         }
     }
 
     bool hasCoverage = forceCoverage || !this->hasSolidCoverage();
 
     // if we don't have coverage we can check whether the dst
     // has to read at all. If not, we'll disable blending.
     if (!hasCoverage) {
         if (dstCoeffIsZero) {
             if (kOne_GrBlendCoeff == *srcCoeff) {
                 // if there is no coverage and coeffs are (1,0) then we
                 // won't need to read the dst at all, it gets replaced by src
                 *dstCoeff = kZero_GrBlendCoeff;
                 return kNone_BlendOpt;
             } else if (kZero_GrBlendCoeff == *srcCoeff) {
                 // if the op is "clear" then we don't need to emit a color
                 // or blend, just write transparent black into the dst.
                 *srcCoeff = kOne_GrBlendCoeff;
                 *dstCoeff = kZero_GrBlendCoeff;
-                return kEmitTransBlack_BlendOptFlag;
+                return kEmitTransBlack_BlendOpt;
             }
         }
     } else if (this->isCoverageDrawing()) {
         // we have coverage but we aren't distinguishing it from alpha by request.
-        return kCoverageAsAlpha_BlendOptFlag;
+        return kCoverageAsAlpha_BlendOpt;
     } else {
         // check whether coverage can be safely rolled into alpha
         // of if we can skip color computation and just emit coverage
         if (this->canTweakAlphaForCoverage()) {
-            return kCoverageAsAlpha_BlendOptFlag;
+            return kCoverageAsAlpha_BlendOpt;
         }
         if (dstCoeffIsZero) {
             if (kZero_GrBlendCoeff == *srcCoeff) {
                 // the source color is not included in the blend
                 // the dst coeff is effectively zero so blend works out to:
                 // (c)(0)D + (1-c)D = (1-c)D.
                 *dstCoeff = kISA_GrBlendCoeff;
-                return  kEmitCoverage_BlendOptFlag;
+                return  kEmitCoverage_BlendOpt;
             } else if (srcAIsOne) {
                 // the dst coeff is effectively zero so blend works out to:
                 // cS + (c)(0)D + (1-c)D = cS + (1-c)D.
                 // If Sa is 1 then we can replace Sa with c
                 // and set dst coeff to 1-Sa.
                 *dstCoeff = kISA_GrBlendCoeff;
-                return  kCoverageAsAlpha_BlendOptFlag;
+                return  kCoverageAsAlpha_BlendOpt;
             }
         } else if (dstCoeffIsOne) {
             // the dst coeff is effectively one so blend works out to:
             // cS + (c)(1)D + (1-c)D = cS + D.
             *dstCoeff = kOne_GrBlendCoeff;
-            return  kCoverageAsAlpha_BlendOptFlag;
+            return  kCoverageAsAlpha_BlendOpt;
         }
     }
 
     return kNone_BlendOpt;
 }
 
 bool GrDrawState::srcAlphaWillBeOne() const {
     this->calcColorInvariantOutput();
     if (this->isCoverageDrawing()) {
         this->calcCoverageInvariantOutput();
@@ skipping 57 matching lines @@
         } else {
             flags = kRGBA_GrColorComponentFlags;
             color = this->getCoverageColor();
         }
         fCoverageProcInfo.calcWithInitialValues(fCoverageStages.begin(), this->numCoverageStages(),
                                                 color, flags, true, fGeometryProcessor.get());
         fCoverageProcInfoValid = true;
     }
 }