Stop using the NVPR glyph loading functionality

src/gpu/gl/GrGLPathRendering.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLPathRendering.h"
 #include "gl/GrGLNameAllocator.h"
 #include "gl/GrGLUtil.h"
@@ skipping 51 matching lines @@
 GrGLPathRendering::GrGLPathRendering(GrGLGpu* gpu)
     : GrPathRendering(gpu) {
     const GrGLInterface* glInterface = gpu->glInterface();
     fCaps.stencilThenCoverSupport =
         NULL != glInterface->fFunctions.fStencilThenCoverFillPath &&
         NULL != glInterface->fFunctions.fStencilThenCoverStrokePath &&
         NULL != glInterface->fFunctions.fStencilThenCoverFillPathInstanced &&
         NULL != glInterface->fFunctions.fStencilThenCoverStrokePathInstanced;
     fCaps.fragmentInputGenSupport =
         NULL != glInterface->fFunctions.fProgramPathFragmentInputGen;
-    fCaps.glyphLoadingSupport =
-        NULL != glInterface->fFunctions.fPathMemoryGlyphIndexArray;
 
     SkASSERT(fCaps.fragmentInputGenSupport);
 }
 
 GrGLPathRendering::~GrGLPathRendering() {
 }
 
 void GrGLPathRendering::abandonGpuResources() {
     fPathNameAllocator.reset(NULL);
 }
 
 void GrGLPathRendering::resetContext() {
     fHWProjectionMatrixState.invalidate();
     // we don't use the model view matrix.
     GL_CALL(MatrixLoadIdentity(GR_GL_PATH_MODELVIEW));
 
     SkASSERT(fCaps.fragmentInputGenSupport);
     fHWPathStencilSettings.invalidate();
 }
 
 GrPath* GrGLPathRendering::createPath(const SkPath& inPath, const GrStrokeInfo& stroke) {
     return SkNEW_ARGS(GrGLPath, (this->gpu(), inPath, stroke));
 }
 
 GrPathRange* GrGLPathRendering::createPathRange(GrPathRange::PathGenerator* pathGenerator,
                                                 const GrStrokeInfo& stroke) {
     return SkNEW_ARGS(GrGLPathRange, (this->gpu(), pathGenerator, stroke));
 }
 
-GrPathRange* GrGLPathRendering::createGlyphs(const SkTypeface* typeface,
-                                             const SkDescriptor* desc,
-                                             const GrStrokeInfo& stroke) {
-    if (NULL != desc || !caps().glyphLoadingSupport || stroke.isDashed()) {
-        return GrPathRendering::createGlyphs(typeface, desc, stroke);
-    }
-
-    if (NULL == typeface) {
-        typeface = SkTypeface::GetDefaultTypeface();
-        SkASSERT(NULL != typeface);
-    }
-
-    int faceIndex;
-    SkStreamAsset* asset = typeface->openStream(&faceIndex);
-    if (!asset) {
-        return GrPathRendering::createGlyphs(typeface, NULL, stroke);
-    }
-    SkAutoTDelete<SkStream> fontStream(asset);
-
-    const size_t fontDataLength = fontStream->getLength();
-    if (0 == fontDataLength) {
-        return GrPathRendering::createGlyphs(typeface, NULL, stroke);
-    }
-
-    SkTArray<uint8_t> fontTempBuffer;
-    const void* fontData = fontStream->getMemoryBase();
-    if (NULL == fontData) {
-        // TODO: Find a more efficient way to pass the font data (e.g. open file descriptor).
-        fontTempBuffer.reset(SkToInt(fontDataLength));
-        fontStream->read(&fontTempBuffer.front(), fontDataLength);
-        fontData = &fontTempBuffer.front();
-    }
-
-    const int numPaths = typeface->countGlyphs();
-    const GrGLuint basePathID = this->genPaths(numPaths);
-
-    // Init the basePathID as the template path.
-    GrGLPath::InitPathObject(this->gpu(), basePathID, SkPath(), stroke);
-
-    GrGLenum status;
-    GL_CALL_RET(status, PathMemoryGlyphIndexArray(basePathID, GR_GL_STANDARD_FONT_FORMAT,
-                                                  fontDataLength, fontData, faceIndex, 0,
-                                                  numPaths, basePathID,
-                                                  SkPaint::kCanonicalTextSizeForPaths));
-
-    if (GR_GL_FONT_GLYPHS_AVAILABLE != status) {
-        this->deletePaths(basePathID, numPaths);
-        return GrPathRendering::createGlyphs(typeface, NULL, stroke);
-    }
-
-    // This is a crude approximation. We may want to consider giving this class
-    // a pseudo PathGenerator whose sole purpose is to track the approximate gpu
-    // memory size.
-    const size_t gpuMemorySize = fontDataLength / 4;
-    return SkNEW_ARGS(GrGLPathRange, (this->gpu(), basePathID, numPaths, gpuMemorySize, stroke));
-}
-
 void GrGLPathRendering::onStencilPath(const StencilPathArgs& args, const GrPath* path) {
     GrGLGpu* gpu = this->gpu();
     SkASSERT(gpu->caps()->shaderCaps()->pathRenderingSupport());
     gpu->flushColorWrite(false);
     gpu->flushDrawFace(GrPipelineBuilder::kBoth_DrawFace);
 
     GrGLRenderTarget* rt = static_cast<GrGLRenderTarget*>(args.fRenderTarget);
     SkISize size = SkISize::Make(rt->width(), rt->height());
     this->setProjectionMatrix(*args.fViewMatrix, size, rt->origin());
     gpu->flushScissor(*args.fScissor, rt->getViewport(), rt->origin());
@@ skipping 237 matching lines @@
 
     GL_CALL(StencilStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                        reference, mask, transformType, transformValues));
     GL_CALL(CoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
                                      coverMode, transformType, transformValues));
 }
 
 inline GrGLGpu* GrGLPathRendering::gpu() {
     return static_cast<GrGLGpu*>(fGpu);
 }