Revert of Generate Signed Distance Field directly from vector path

src/gpu/batches/GrAADistanceFieldPathRenderer.cpp

 /*
  * Copyright 2014 Google Inc.
- * Copyright 2016 ARM Ltd.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrBuffer.h"
 #include "GrContext.h"
 #include "GrPipelineBuilder.h"
 #include "GrResourceProvider.h"
 #include "GrSurfacePriv.h"
 #include "GrSWMaskHelper.h"
 #include "GrTexturePriv.h"
 #include "batches/GrVertexBatch.h"
 #include "effects/GrDistanceFieldGeoProc.h"
 
-#include "SkPathOps.h"
 #include "SkDistanceFieldGen.h"
-#include "GrDistanceFieldGenFromVector.h"
 
 #define ATLAS_TEXTURE_WIDTH 2048
 #define ATLAS_TEXTURE_HEIGHT 2048
 #define PLOT_WIDTH  512
 #define PLOT_HEIGHT 256
 
 #define NUM_PLOTS_X   (ATLAS_TEXTURE_WIDTH / PLOT_WIDTH)
 #define NUM_PLOTS_Y   (ATLAS_TEXTURE_HEIGHT / PLOT_HEIGHT)
 
 #ifdef DF_PATH_TRACKING
@@ skipping 71 matching lines @@
         return false;
     }
 
     // only support paths with bounds within kMediumMIP by kMediumMIP,
     // scaled to have bounds within 2.0f*kLargeMIP by 2.0f*kLargeMIP
     // the goal is to accelerate rendering of lots of small paths that may be scaling
     SkScalar maxScale = args.fViewMatrix->getMaxScale();
     SkRect bounds = args.fShape->styledBounds();
     SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
 
-    if (!(maxDim <= kMediumMIP && maxDim * maxScale <= 2.0f*kLargeMIP)) {
-        return false;
-    }
-
-    // Only support even-odd fill type. (Checked by the IsDistanceFieldSupportedFillType function)
-    // The Simplify operation can convert some paths into even-odd fill type.
-    // Check whether we can generate distance field from this path after Simplify.
-    // TODO: Cache the simplifiedPath/workingPath somewhere for later use.
-    SkPath path;
-    args.fShape->asPath(&path);
-    SkPath simplifiedPath;
-    const SkPath* workingPath;
-    if (Simplify(path, &simplifiedPath)) {
-        workingPath = &simplifiedPath;
-    } else {
-        workingPath = &path;
-    }
-    return IsDistanceFieldSupportedFillType(workingPath->getFillType());
+    return maxDim <= kMediumMIP && maxDim * maxScale <= 2.0f*kLargeMIP;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // padding around path bounds to allow for antialiased pixels
 static const SkScalar kAntiAliasPad = 1.0f;
 
 class AADistanceFieldPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
@@ skipping 194 matching lines @@
         devPathBounds.fRight = intPad + width;
         devPathBounds.fBottom = intPad + height;
         devPathBounds.outset(intPad, intPad);
 
         // draw path to bitmap
         SkMatrix drawMatrix;
         drawMatrix.setTranslate(-bounds.left(), -bounds.top());
         drawMatrix.postScale(scale, scale);
         drawMatrix.postTranslate(kAntiAliasPad, kAntiAliasPad);
 
+        // setup bitmap backing
         SkASSERT(devPathBounds.fLeft == 0);
         SkASSERT(devPathBounds.fTop == 0);
+        SkAutoPixmapStorage dst;
+        if (!dst.tryAlloc(SkImageInfo::MakeA8(devPathBounds.width(),
+                                              devPathBounds.height()))) {
+            return false;
+        }
+        sk_bzero(dst.writable_addr(), dst.getSafeSize());
+
+        // rasterize path
+        SkPaint paint;
+        paint.setStyle(SkPaint::kFill_Style);
+        paint.setAntiAlias(antiAlias);
+
+        SkDraw draw;
+        sk_bzero(&draw, sizeof(draw));
+
+        SkRasterClip rasterClip;
+        rasterClip.setRect(devPathBounds);
+        draw.fRC = &rasterClip;
+        draw.fMatrix = &drawMatrix;
+        draw.fDst = dst;
 
         SkPath path;
         shape.asPath(&path);
+        draw.drawPathCoverage(path, paint);
 
-        // setup signed distance field storage
+        // generate signed distance field
         devPathBounds.outset(SK_DistanceFieldPad, SK_DistanceFieldPad);
         width = devPathBounds.width();
         height = devPathBounds.height();
         // TODO We should really generate this directly into the plot somehow
         SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char));
 
-        // Generate signed distance field directly from SkPath
-        GrGenerateDistanceFieldFromPath((unsigned char*)dfStorage.get(),
-                                        path, drawMatrix,
-                                        width, height, width * sizeof(unsigned char));
+        // Generate signed distance field
+        SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
+                                           (const unsigned char*)dst.addr(),
+                                           dst.width(), dst.height(), dst.rowBytes());
 
         // add to atlas
         SkIPoint16 atlasLocation;
         GrBatchAtlas::AtlasID id;
        if (!atlas->addToAtlas(&id, target, width, height, dfStorage.get(), &atlasLocation)) {
             this->flush(target, flushInfo);
             if (!atlas->addToAtlas(&id, target, width, height, dfStorage.get(), &atlasLocation)) {
                 return false;
             }
         }
@@ skipping 234 matching lines @@
                                         shape,
                                         antiAlias,
                                         viewMatrix,
                                         gTestStruct.fAtlas,
                                         &gTestStruct.fShapeCache,
                                         &gTestStruct.fShapeList,
                                         gammaCorrect);
 }
 
 #endif