Revert "speed up A8 by creating a new entry-point in SkDraw that blits the path's coverage directly…

src/gpu/GrSWMaskHelper.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 "GrSWMaskHelper.h"
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
@@ skipping 55 matching lines @@
     } else {
         if (stroke.isFillStyle()) {
             paint.setStyle(SkPaint::kFill_Style);
         } else {
             paint.setStyle(SkPaint::kStroke_Style);
             paint.setStrokeJoin(stroke.getJoin());
             paint.setStrokeCap(stroke.getCap());
             paint.setStrokeWidth(stroke.getWidth());
         }
     }
+
+    SkXfermode* mode = SkXfermode::Create(op_to_mode(op));
+
+    paint.setXfermode(mode);
     paint.setAntiAlias(antiAlias);
+    paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
 
-    if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
-        SkASSERT(0xFF == paint.getAlpha());
-        fDraw.drawPathCoverage(path, paint);
-    } else {
-        paint.setXfermodeMode(op_to_mode(op));
-        paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
-        fDraw.drawPath(path, paint);
-    }
+    fDraw.drawPath(path, paint);
+
+    SkSafeUnref(mode);
 }
 
 bool GrSWMaskHelper::init(const SkIRect& resultBounds,
-                          const SkMatrix* matrix,
-                          bool zeroPixels) {
+                          const SkMatrix* matrix) {
     if (NULL != matrix) {
         fMatrix = *matrix;
     } else {
         fMatrix.setIdentity();
     }
 
     // Now translate so the bound's UL corner is at the origin
     fMatrix.postTranslate(-resultBounds.fLeft * SK_Scalar1,
                           -resultBounds.fTop * SK_Scalar1);
     SkIRect bounds = SkIRect::MakeWH(resultBounds.width(),
                                      resultBounds.height());
 
     fBM.setConfig(SkBitmap::kA8_Config, bounds.fRight, bounds.fBottom);
     if (!fBM.allocPixels()) {
         return false;
     }
-    if (zeroPixels) {
-        sk_bzero(fBM.getPixels(), fBM.getSafeSize());
-    }
+    sk_bzero(fBM.getPixels(), fBM.getSafeSize());
 
     sk_bzero(&fDraw, sizeof(fDraw));
     fRasterClip.setRect(bounds);
     fDraw.fRC    = &fRasterClip;
     fDraw.fClip  = &fRasterClip.bwRgn();
     fDraw.fMatrix = &fMatrix;
     fDraw.fBitmap = &fBM;
     return true;
 }
 
@@ skipping 39 matching lines @@
 GrTexture* GrSWMaskHelper::DrawPathMaskToTexture(GrContext* context,
                                                  const SkPath& path,
                                                  const SkStrokeRec& stroke,
                                                  const SkIRect& resultBounds,
                                                  bool antiAlias,
                                                  SkMatrix* matrix) {
     GrAutoScratchTexture ast;
 
     GrSWMaskHelper helper(context);
 
-    if (!helper.init(resultBounds, matrix, false)) {
+    if (!helper.init(resultBounds, matrix)) {
         return NULL;
     }
 
     helper.draw(path, stroke, SkRegion::kReplace_Op, antiAlias, 0xFF);
 
     if (!helper.getTexture(&ast)) {
         return NULL;
     }
 
     helper.toTexture(ast.texture());
@@ skipping 27 matching lines @@
     maskMatrix.preConcat(drawState->getViewMatrix());
 
     drawState->addCoverageEffect(
                          GrSimpleTextureEffect::Create(texture,
                                                        maskMatrix,
                                                        GrTextureParams::kNone_FilterMode,
                                                        kPosition_GrCoordSet))->unref();
 
     target->drawSimpleRect(dstRect);
 }