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

src/gpu/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 346 matching lines @@
                           drawState,
                           &primType,
                           &vertexCnt,
                           &indexCnt,
                           &arg,
                           path,
                           *stroke,
                           tol)) {
         return false;
     }
-
-    bool colorWritesWereDisabled = drawState->isColorWriteDisabled();
+    // Save the current xp on the draw state so we can reset it if needed
+    SkAutoTUnref<const GrXPFactory> backupXPFactory(SkRef(drawState->getXPFactory()));
     // face culling doesn't make sense here
     SkASSERT(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
 
     int                         passCount = 0;
     const GrStencilSettings*    passes[3];
     GrDrawState::DrawFace       drawFace[3];
     bool                        reverse = false;
     bool                        lastPassIsBounds;
 
     if (stroke->isHairlineStyle()) {
@@ skipping 85 matching lines @@
     SkRect devBounds;
     GetPathDevBounds(path, drawState->getRenderTarget(), viewM, &devBounds);
 
     for (int p = 0; p < passCount; ++p) {
         drawState->setDrawFace(drawFace[p]);
         if (passes[p]) {
             *drawState->stencil() = *passes[p];
         }
 
         if (lastPassIsBounds && (p == passCount-1)) {
-            if (!colorWritesWereDisabled) {
-                drawState->disableState(GrDrawState::kNoColorWrites_StateBit);
-            }
+            // Reset the XP Factory on drawState
+            drawState->setXPFactory(backupXPFactory);
             SkRect bounds;
             GrDrawState::AutoViewMatrixRestore avmr;
             if (reverse) {
                 SkASSERT(drawState->getRenderTarget());
                 // draw over the dev bounds (which will be the whole dst surface for inv fill).
                 bounds = devBounds;
                 SkMatrix vmi;
                 // mapRect through persp matrix may not be correct
                 if (!drawState->getViewMatrix().hasPerspective() &&
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     avmr.setIdentity(drawState);
                 }
             } else {
                 bounds = path.getBounds();
             }
             GrDrawTarget::AutoGeometryPush agp(target);
             target->drawSimpleRect(drawState, color, bounds);
         } else {
             if (passCount > 1) {
-                drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
+                drawState->setDisableColorXPFactory();
             }
             GrDrawState::AutoRestoreEffects are(drawState);
             SkAutoTUnref<const GrGeometryProcessor> gp(
                     GrDefaultGeoProcFactory::Create(color,
                                                     GrDefaultGeoProcFactory::kPosition_GPType,
                                                     false,
                                                     newCoverage));
             if (indexCnt) {
                 target->drawIndexed(drawState,
                                     gp,
@@ skipping 38 matching lines @@
 }
 
 void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target,
                                           GrDrawState* drawState,
                                           const SkPath& path,
                                           const SkStrokeRec& stroke) {
     SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(target, drawState, GrColor_WHITE, path, stroke, true);
 }