Add XP to handle the cases where we disable color write.

src/gpu/gl/GrGpuGL.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpuGL.h"
 #include "GrGLStencilBuffer.h"
@@ skipping 1326 matching lines @@
             }
             return;
         }
     }
 
     // See fall through note above
     this->disableScissor();
 }
 
 bool GrGLGpu::flushGLState(const GrOptDrawState& optState) {
+    GrXferProcessor::BlendInfo blendInfo;
+    optState.getXferProcessor()->getBlendInfo(&blendInfo);
+
     this->flushDither(optState.isDitherState());
-    this->flushColorWriteDisable(optState.isColorWriteDisabled());
+    this->flushColorWrite(blendInfo.fWriteColor);
     this->flushDrawFace(optState.getDrawFace());
 
     fCurrentProgram.reset(fProgramCache->getProgram(optState));
     if (NULL == fCurrentProgram.get()) {
         SkDEBUGFAIL("Failed to create program!");
         return false;
     }
 
     fCurrentProgram.get()->ref();
 
     GrGLuint programID = fCurrentProgram->programID();
     if (fHWProgramID != programID) {
         GL_CALL(UseProgram(programID));
         fHWProgramID = programID;
     }
 
-    this->flushBlend(optState);
+    if (blendInfo.fWriteColor) {
+        this->flushBlend(blendInfo);
+    }
 
     fCurrentProgram->setData(optState);
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget());
     this->flushStencil(optState.getStencil());
     this->flushScissor(optState.getScissorState(), glRT->getViewport(), glRT->origin());
     this->flushHWAAState(glRT, optState.isHWAntialiasState(),
                          kDrawLines_DrawType == optState.drawType());
 
     // This must come after textures are flushed because a texture may need
@@ skipping 481 matching lines @@
         aglSwapBuffers(aglGetCurrentContext());
     #elif defined(SK_BUILD_FOR_WIN32)
         SwapBuf();
         int set_a_break_pt_here = 9;
         SwapBuf();
     #endif
 #endif
 }
 
 void GrGLGpu::onStencilPath(const GrPath* path, const StencilPathState& state) {
-    this->flushColorWriteDisable(true);
+    this->flushColorWrite(false);
     this->flushDrawFace(GrDrawState::kBoth_DrawFace);
 
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(state.fRenderTarget);
     SkISize size = SkISize::Make(rt->width(), rt->height());
     this->glPathRendering()->setProjectionMatrix(*state.fViewMatrix, size, rt->origin());
     this->flushScissor(*state.fScissor, rt->getViewport(), rt->origin());
     this->flushHWAAState(rt, state.fUseHWAA, false);
     this->flushRenderTarget(rt, NULL);
 
     fPathRendering->stencilPath(path, *state.fStencil);
@@ skipping 170 matching lines @@
             } else {
                 if (kNo_TriState != fMSAAEnabled) {
                     GL_CALL(Disable(GR_GL_MULTISAMPLE));
                     fMSAAEnabled = kNo_TriState;
                 }
             }
         }
     }
 }
 
-void GrGLGpu::flushBlend(const GrOptDrawState& optState) {
+void GrGLGpu::flushBlend(const GrXferProcessor::BlendInfo& blendInfo) {
     // Any optimization to disable blending should have already been applied and
     // tweaked the coeffs to (1, 0).
     
-    GrXferProcessor::BlendInfo blendInfo;
-    optState.getXferProcessor()->getBlendInfo(&blendInfo);
     GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
     GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
     bool blendOff = kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff;
     if (blendOff) {
         if (kNo_TriState != fHWBlendState.fEnabled) {
             GL_CALL(Disable(GR_GL_BLEND));
             fHWBlendState.fEnabled = kNo_TriState;
         }
     } else {
         if (kYes_TriState != fHWBlendState.fEnabled) {
@@ skipping 141 matching lines @@
             fHWDitherEnabled = kYes_TriState;
         }
     } else {
         if (kNo_TriState != fHWDitherEnabled) {
             GL_CALL(Disable(GR_GL_DITHER));
             fHWDitherEnabled = kNo_TriState;
         }
     }
 }
 
-void GrGLGpu::flushColorWriteDisable(bool disableColorWrites) {
-    if (disableColorWrites) {
+void GrGLGpu::flushColorWrite(bool writeColor) {
+    if (!writeColor) {
         if (kNo_TriState != fHWWriteToColor) {
             GL_CALL(ColorMask(GR_GL_FALSE, GR_GL_FALSE,
                               GR_GL_FALSE, GR_GL_FALSE));
             fHWWriteToColor = kNo_TriState;
         }
     } else {
         if (kYes_TriState != fHWWriteToColor) {
             GL_CALL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE));
             fHWWriteToColor = kYes_TriState;
         }
@@ skipping 499 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }