Remove GrPipelineBuilder from getPathRenderer call

src/gpu/GrDrawingManager.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 "GrAtlasTextContext.h"
 #include "GrDrawContext.h"
 #include "GrDrawingManager.h"
 #include "GrDrawTarget.h"
 #include "GrResourceProvider.h"
+#include "GrSoftwarePathRenderer.h"
 #include "GrStencilAndCoverTextContext.h"
 #include "SkTTopoSort.h"
 
 void GrDrawingManager::cleanup() {
     for (int i = 0; i < fDrawTargets.count(); ++i) {
         fDrawTargets[i]->unref();
     }
 
     fDrawTargets.reset();
 
     delete fNVPRTextContext;
     fNVPRTextContext = nullptr;
 
     for (int i = 0; i < kNumPixelGeometries; ++i) {
         delete fTextContexts[i][0];
         fTextContexts[i][0] = nullptr;
         delete fTextContexts[i][1];
         fTextContexts[i][1] = nullptr;
     }
+
+    SkSafeSetNull(fPathRendererChain);
+    SkSafeSetNull(fSoftwarePathRenderer);
 }
 
 GrDrawingManager::~GrDrawingManager() {
     this->cleanup();
 }
 
 void GrDrawingManager::abandon() {
     fAbandoned = true;
     this->cleanup();
 }
 
+void GrDrawingManager::freeGpuResources() {
+    // a path renderer may be holding onto resources
+    SkSafeSetNull(fPathRendererChain);
+    SkSafeSetNull(fSoftwarePathRenderer);
+}
+
 void GrDrawingManager::reset() {
     for (int i = 0; i < fDrawTargets.count(); ++i) {
         fDrawTargets[i]->reset();
     }
 }
 
 void GrDrawingManager::flush() {
     SkDEBUGCODE(bool result =) 
                         SkTTopoSort<GrDrawTarget, GrDrawTarget::TopoSortTraits>(&fDrawTargets);
     SkASSERT(result);
@@ skipping 54 matching lines @@
 
     GrDrawTarget* dt = new GrDrawTarget(fContext->getGpu(), fContext->resourceProvider(),
                                         fOptions);
 
     *fDrawTargets.append() = dt;
 
     // DrawingManager gets the creation ref - this ref is for the caller 
     return SkRef(dt);
 }
 
-GrDrawContext* GrDrawingManager::drawContext(GrRenderTarget* rt, 
+/*
+ * This method finds a path renderer that can draw the specified path on
+ * the provided target.
+ * Due to its expense, the software path renderer has split out so it can
+ * can be individually allowed/disallowed via the "allowSW" boolean.
+ */
+GrPathRenderer* GrDrawingManager::getPathRenderer(const GrPathRenderer::CanDrawPathArgs& args,
+                                                  bool allowSW,
+                                                  GrPathRendererChain::DrawType drawType,
+                                                  GrPathRenderer::StencilSupport* stencilSupport) {
+
+    if (!fPathRendererChain) {
+        fPathRendererChain = new GrPathRendererChain(fContext);
+    }
+
+    GrPathRenderer* pr = fPathRendererChain->getPathRenderer(args, drawType, stencilSupport);
+    if (!pr && allowSW) {
+        if (!fSoftwarePathRenderer) {
+            fSoftwarePathRenderer = new GrSoftwarePathRenderer(fContext);
+        }
+        pr = fSoftwarePathRenderer;
+    }
+
+    return pr;
+}
+
+GrDrawContext* GrDrawingManager::drawContext(GrRenderTarget* rt,
                                              const SkSurfaceProps* surfaceProps) {
     if (this->abandoned()) {
         return nullptr;
     }
 
     return new GrDrawContext(this, rt, surfaceProps);
 }