Make GrGLShaderBuilder::TextureSampler extract only required info from GrTextureAccess.

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 218 matching lines @@
 
 bool GrDrawState::srcAlphaWillBeOne(GrAttribBindings bindings) const {
 
     uint32_t validComponentFlags;
     GrColor color;
     // Check if per-vertex or constant color may have partial alpha
     if (bindings & kColor_AttribBindingsBit) {
         validComponentFlags = 0;
         color = 0; // not strictly necessary but we get false alarms from tools about uninit.
     } else {
-        validComponentFlags = GrEffect::kAll_ValidComponentFlags;
+        validComponentFlags = kRGBA_GrColorComponentFlags;
         color = this->getColor();
     }
 
     // Run through the color stages
     int stageCnt = getFirstCoverageStage();
     for (int s = 0; s < stageCnt; ++s) {
         const GrEffectRef* effect = this->getStage(s).getEffect();
         if (NULL != effect) {
             (*effect)->getConstantColorComponents(&color, &validComponentFlags);
         }
@@ skipping 18 matching lines @@
                 color |= (SkMulDiv255Round(a, b) << (c * 8));
             }
         }
         for (int s = this->getFirstCoverageStage(); s < GrDrawState::kNumStages; ++s) {
             const GrEffectRef* effect = this->getStage(s).getEffect();
             if (NULL != effect) {
                 (*effect)->getConstantColorComponents(&color, &validComponentFlags);
             }
         }
     }
-    return (GrEffect::kA_ValidComponentFlag & validComponentFlags) && 0xff == GrColorUnpackA(color);
+    return (kA_GrColorComponentFlag & validComponentFlags) && 0xff == GrColorUnpackA(color);
 }
 
 bool GrDrawState::hasSolidCoverage(GrAttribBindings bindings) 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 (bindings & kCoverage_AttribBindingsBit) {
         validComponentFlags = 0;
     } else {
         coverage = fCommon.fCoverage;
-        validComponentFlags = GrEffect::kAll_ValidComponentFlags;
+        validComponentFlags = kRGBA_GrColorComponentFlags;
     }
 
     // Run through the coverage stages and see if the coverage will be all ones at the end.
     for (int s = this->getFirstCoverageStage(); s < GrDrawState::kNumStages; ++s) {
         const GrEffectRef* effect = this->getStage(s).getEffect();
         if (NULL != effect) {
             (*effect)->getConstantColorComponents(&coverage, &validComponentFlags);
         }
     }
-    return (GrEffect::kAll_ValidComponentFlags == validComponentFlags)  && (0xffffffff == coverage);
+    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 {
     /*
      The fractional coverage is f.
      The src and dst coeffs are Cs and Cd.
@@ skipping 190 matching lines @@
             }
             fRestoreMask |= (1 << s);
             GrEffectStage* stage = drawState->fStages + s;
             stage->saveCoordChange(&fSavedCoordChanges[s]);
             stage->localCoordChange(invVM);
         }
     }
     drawState->viewMatrix()->reset();
     return true;
 }