Revert of Generate Signed Distance Field directly from vector path

src/gpu/text/GrAtlasGlyphCache.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasGlyphCache.h"
 #include "GrContext.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
 #include "GrResourceProvider.h"
 #include "GrSurfacePriv.h"
 #include "SkString.h"
 
 #include "SkDistanceFieldGen.h"
-#include "GrDistanceFieldGenFromVector.h"
 
 bool GrAtlasGlyphCache::initAtlas(GrMaskFormat format) {
     int index = MaskFormatToAtlasIndex(format);
     if (!fAtlases[index]) {
         GrPixelConfig config = MaskFormatToPixelConfig(format, *fContext->caps());
         int width = fAtlasConfigs[index].fWidth;
         int height = fAtlasConfigs[index].fHeight;
         int numPlotsX = fAtlasConfigs[index].numPlotsX();
         int numPlotsY = fAtlasConfigs[index].numPlotsY();
 
@@ skipping 286 matching lines @@
             dst = (char*)dst + dstRB;
         }
     }
     return true;
 }
 
 static bool get_packed_glyph_df_image(SkGlyphCache* cache, const SkGlyph& glyph,
                                       int width, int height, void* dst) {
     SkASSERT(glyph.fWidth + 2*SK_DistanceFieldPad == width);
     SkASSERT(glyph.fHeight + 2*SK_DistanceFieldPad == height);
-
-#ifndef SK_USE_LEGACY_DISTANCE_FIELDS
-    const SkPath* path = cache->findPath(glyph);
-    if (nullptr == path) {
+    const void* image = cache->findImage(glyph);
+    if (nullptr == image) {
+        return false;
+    }
+    // now generate the distance field
+    SkASSERT(dst);
+    SkMask::Format maskFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
+    if (SkMask::kA8_Format == maskFormat) {
+        // make the distance field from the image
+        SkGenerateDistanceFieldFromA8Image((unsigned char*)dst,
+                                           (unsigned char*)image,
+                                           glyph.fWidth, glyph.fHeight,
+                                           glyph.rowBytes());
+    } else if (SkMask::kBW_Format == maskFormat) {
+        // make the distance field from the image
+        SkGenerateDistanceFieldFromBWImage((unsigned char*)dst,
+                                           (unsigned char*)image,
+                                           glyph.fWidth, glyph.fHeight,
+                                           glyph.rowBytes());
+    } else {
         return false;
     }
 
-    // now generate the distance field
-    SkASSERT(dst);
-    SkMatrix drawMatrix;
-    drawMatrix.setTranslate((SkScalar)-glyph.fLeft, (SkScalar)-glyph.fTop);
-
-    // Generate signed distance field directly from SkPath
-    bool succeed = GrGenerateDistanceFieldFromPath((unsigned char*)dst,
-                                           *path, drawMatrix,
-                                           width, height, width * sizeof(unsigned char));
-
-    if (!succeed) {
-#endif
-        const void* image = cache->findImage(glyph);
-        if (nullptr == image) {
-            return false;
-        }
-
-        // now generate the distance field
-        SkASSERT(dst);
-        SkMask::Format maskFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
-        if (SkMask::kA8_Format == maskFormat) {
-            // make the distance field from the image
-            SkGenerateDistanceFieldFromA8Image((unsigned char*)dst,
-                                               (unsigned char*)image,
-                                               glyph.fWidth, glyph.fHeight,
-                                               glyph.rowBytes());
-        } else if (SkMask::kBW_Format == maskFormat) {
-            // make the distance field from the image
-            SkGenerateDistanceFieldFromBWImage((unsigned char*)dst,
-                                               (unsigned char*)image,
-                                               glyph.fWidth, glyph.fHeight,
-                                               glyph.rowBytes());
-        } else {
-            return false;
-        }
-#ifndef SK_USE_LEGACY_DISTANCE_FIELDS
-    }
-#endif
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*
     The text strike is specific to a given font/style/matrix setup, which is
     represented by the GrHostFontScaler object we are given in getGlyph().
 
     We map a 32bit glyphID to a GrGlyph record, which in turn points to a
@@ skipping 76 matching lines @@
 
     bool success = fAtlasGlyphCache->addToAtlas(this, &glyph->fID, target, expectedMaskFormat,
                                                glyph->width(), glyph->height(),
                                                storage.get(), &glyph->fAtlasLocation);
     if (success) {
         SkASSERT(GrDrawOpAtlas::kInvalidAtlasID != glyph->fID);
         fAtlasedGlyphs++;
     }
     return success;
 }