Remove use of GrEffectRef from draw state and below.

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 "GrPaint.h"
 
@@ skipping 133 matching lines @@
 bool GrDrawState::validateVertexAttribs() const {
     // check consistency of effects and attributes
     GrSLType slTypes[kMaxVertexAttribCnt];
     for (int i = 0; i < kMaxVertexAttribCnt; ++i) {
         slTypes[i] = static_cast<GrSLType>(-1);
     }
     int totalStages = fColorStages.count() + fCoverageStages.count();
     for (int s = 0; s < totalStages; ++s) {
         int covIdx = s - fColorStages.count();
         const GrEffectStage& stage = covIdx < 0 ? fColorStages[s] : fCoverageStages[covIdx];
-        const GrEffectRef* effect = stage.getEffect();
+        const GrEffect* effect = stage.getEffect();
         SkASSERT(NULL != effect);
         // make sure that any attribute indices have the correct binding type, that the attrib
         // type and effect's shader lang type are compatible, and that attributes shared by
         // multiple effects use the same shader lang type.
         const int* attributeIndices = stage.getVertexAttribIndices();
         int numAttributes = stage.getVertexAttribIndexCount();
         for (int i = 0; i < numAttributes; ++i) {
             int attribIndex = attributeIndices[i];
             if (attribIndex >= fVACount ||
                 kEffect_GrVertexAttribBinding != fVAPtr[attribIndex].fBinding) {
                 return false;
             }
 
-            GrSLType effectSLType = (*effect)->vertexAttribType(i);
+            GrSLType effectSLType = effect->vertexAttribType(i);
             GrVertexAttribType attribType = fVAPtr[attribIndex].fType;
             int slVecCount = GrSLTypeVectorCount(effectSLType);
             int attribVecCount = GrVertexAttribTypeVectorCount(attribType);
             if (slVecCount != attribVecCount ||
                 (static_cast<GrSLType>(-1) != slTypes[attribIndex] &&
                     slTypes[attribIndex] != effectSLType)) {
                 return false;
             }
             slTypes[attribIndex] = effectSLType;
         }
     }
 
     return true;
 }
 
 bool GrDrawState::willEffectReadDstColor() const {
     if (!this->isColorWriteDisabled()) {
         for (int s = 0; s < fColorStages.count(); ++s) {
-            if ((*fColorStages[s].getEffect())->willReadDstColor()) {
+            if (fColorStages[s].getEffect()->willReadDstColor()) {
                 return true;
             }
         }
     }
     for (int s = 0; s < fCoverageStages.count(); ++s) {
-        if ((*fCoverageStages[s].getEffect())->willReadDstColor()) {
+        if (fCoverageStages[s].getEffect()->willReadDstColor()) {
             return true;
         }
     }
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawState::srcAlphaWillBeOne() const {
     uint32_t validComponentFlags;
     GrColor color;
     // Check if per-vertex or constant color may have partial alpha
     if (this->hasColorVertexAttribute()) {
         validComponentFlags = 0;
         color = 0; // not strictly necessary but we get false alarms from tools about uninit.
     } else {
         validComponentFlags = kRGBA_GrColorComponentFlags;
         color = this->getColor();
     }
 
     // Run through the color stages
     for (int s = 0; s < fColorStages.count(); ++s) {
-        const GrEffectRef* effect = fColorStages[s].getEffect();
-        (*effect)->getConstantColorComponents(&color, &validComponentFlags);
+        const GrEffect* effect = fColorStages[s].getEffect();
+        effect->getConstantColorComponents(&color, &validComponentFlags);
     }
 
     // Check whether coverage is treated as color. If so we run through the coverage computation.
     if (this->isCoverageDrawing()) {
         GrColor coverageColor = this->getCoverageColor();
         GrColor oldColor = color;
         color = 0;
         for (int c = 0; c < 4; ++c) {
             if (validComponentFlags & (1 << c)) {
                 U8CPU a = (oldColor >> (c * 8)) & 0xff;
                 U8CPU b = (coverageColor >> (c * 8)) & 0xff;
                 color |= (SkMulDiv255Round(a, b) << (c * 8));
             }
         }
         for (int s = 0; s < fCoverageStages.count(); ++s) {
-            const GrEffectRef* effect = fCoverageStages[s].getEffect();
-            (*effect)->getConstantColorComponents(&color, &validComponentFlags);
+            const GrEffect* effect = fCoverageStages[s].getEffect();
+            effect->getConstantColorComponents(&color, &validComponentFlags);
         }
     }
     return (kA_GrColorComponentFlag & validComponentFlags) && 0xff == GrColorUnpackA(color);
 }
 
 bool GrDrawState::hasSolidCoverage() const {
     // If we're drawing coverage directly then coverage is effectively treated as color.
     if (this->isCoverageDrawing()) {
         return true;
     }
 
     GrColor coverage;
     uint32_t validComponentFlags;
     // Initialize to an unknown starting coverage if per-vertex coverage is specified.
     if (this->hasCoverageVertexAttribute()) {
         validComponentFlags = 0;
     } else {
         coverage = fCoverage;
         validComponentFlags = kRGBA_GrColorComponentFlags;
     }
 
     // Run through the coverage stages and see if the coverage will be all ones at the end.
     for (int s = 0; s < fCoverageStages.count(); ++s) {
-        const GrEffectRef* effect = fCoverageStages[s].getEffect();
-        (*effect)->getConstantColorComponents(&coverage, &validComponentFlags);
+        const GrEffect* effect = fCoverageStages[s].getEffect();
+        effect->getConstantColorComponents(&coverage, &validComponentFlags);
     }
     return (kRGBA_GrColorComponentFlags == validComponentFlags) && (0xffffffff == coverage);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Some blend modes allow folding a fractional coverage value into the color's alpha channel, while
 // others will blend incorrectly.
 bool GrDrawState::canTweakAlphaForCoverage() const {
     /*
@@ skipping 196 matching lines @@
         fDrawState->fColorStages[s].saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fColorStages[s].localCoordChange(coordChangeMatrix);
     }
 
     int numCoverageStages = fDrawState->numCoverageStages();
     for (int s = 0; s < numCoverageStages; ++s, ++i) {
         fDrawState->fCoverageStages[s].saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fCoverageStages[s].localCoordChange(coordChangeMatrix);
     }
 }