diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp
index fd1d30b..ea126b1 100644
--- a/src/gpu/GrOvalRenderer.cpp
+++ b/src/gpu/GrOvalRenderer.cpp
@@ -791,6 +791,7 @@
                            fGeoData[i].fInnerRadius,
                            fGeoData[i].fOuterRadius);
         }
+        string.append(DumpPipelineInfo(*this->pipeline()));
         string.append(INHERITED::dumpInfo());
         return string;
     }
@@ -1231,6 +1232,25 @@
 
     const char* name() const override { return "EllipseBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.appendf("Stroked: %d\n", fStroked);
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], "
+                           "XRad: %.2f, YRad: %.2f, InnerXRad: %.2f, InnerYRad: %.2f\n",
+                           geo.fColor,
+                           geo.fDevBounds.fLeft, geo.fDevBounds.fTop,
+                           geo.fDevBounds.fRight, geo.fDevBounds.fBottom,
+                           geo.fXRadius,
+                           geo.fYRadius,
+                           geo.fInnerXRadius,
+                           geo.fInnerYRadius);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
@@ -1443,6 +1463,27 @@
 
     const char* name() const override { return "DIEllipseBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], XRad: %.2f, "
+                           "YRad: %.2f, InnerXRad: %.2f, InnerYRad: %.2f, GeoDX: %.2f, "
+                           "GeoDY: %.2f\n",
+                           geo.fColor,
+                           geo.fBounds.fLeft, geo.fBounds.fTop,
+                           geo.fBounds.fRight, geo.fBounds.fBottom,
+                           geo.fXRadius,
+                           geo.fYRadius,
+                           geo.fInnerXRadius,
+                           geo.fInnerYRadius,
+                           geo.fGeoDx,
+                           geo.fGeoDy);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
@@ -1754,6 +1795,7 @@
                            fGeoData[i].fInnerRadius,
                            fGeoData[i].fOuterRadius);
         }
+        string.append(DumpPipelineInfo(*this->pipeline()));
         string.append(INHERITED::dumpInfo());
         return string;
     }
@@ -2104,6 +2146,25 @@
 
     const char* name() const override { return "RRectEllipseRendererBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.appendf("Stroked: %d\n", fStroked);
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], "
+                           "XRad: %.2f, YRad: %.2f, InnerXRad: %.2f, InnerYRad: %.2f\n",
+                           geo.fColor,
+                           geo.fDevBounds.fLeft, geo.fDevBounds.fTop,
+                           geo.fDevBounds.fRight, geo.fDevBounds.fBottom,
+                           geo.fXRadius,
+                           geo.fYRadius,
+                           geo.fInnerXRadius,
+                           geo.fInnerYRadius);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrAAConvexPathRenderer.cpp b/src/gpu/batches/GrAAConvexPathRenderer.cpp
index bec774c..1be84c7 100644
--- a/src/gpu/batches/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/batches/GrAAConvexPathRenderer.cpp
@@ -744,6 +744,16 @@
 
     const char* name() const override { return "AAConvexBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x\n", geo.fColor);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp b/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
index 9f4274d..e911927 100644
--- a/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp
@@ -154,6 +154,16 @@
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x AA:%d\n", geo.fColor, geo.fAntiAlias);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrAAFillRectBatch.cpp b/src/gpu/batches/GrAAFillRectBatch.cpp
index fd2a4c4..46a5d50 100644
--- a/src/gpu/batches/GrAAFillRectBatch.cpp
+++ b/src/gpu/batches/GrAAFillRectBatch.cpp
@@ -191,6 +191,7 @@
                         i, info->color(), rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
             info = this->next(info);
         }
+        str.append(DumpPipelineInfo(*this->pipeline()));
         str.append(INHERITED::dumpInfo());
         return str;
     }
diff --git a/src/gpu/batches/GrAAHairLinePathRenderer.cpp b/src/gpu/batches/GrAAHairLinePathRenderer.cpp
index 70c4911..b2ad9ba 100644
--- a/src/gpu/batches/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/batches/GrAAHairLinePathRenderer.cpp
@@ -692,6 +692,16 @@
 
     const char* name() const override { return "AAHairlineBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x Coverage: 0x%02x\n", geo.fColor, geo.fCoverage);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
index d53fe9c..f8516b9 100644
--- a/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp
@@ -151,7 +151,19 @@
         this->setTransformedBounds(bounds, viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
     }
 
-    const char* name() const override { return "AAConvexBatch"; }
+    const char* name() const override { return "AAFlatteningConvexBatch"; }
+
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x, StrokeWidth: %.2f, Style: %d, Join: %d, "
+                           "MiterLimit: %.2f\n",
+                           geo.fColor, geo.fStrokeWidth, geo.fStyle, geo.fJoin, geo.fMiterLimit);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
diff --git a/src/gpu/batches/GrAAStrokeRectBatch.cpp b/src/gpu/batches/GrAAStrokeRectBatch.cpp
index f3c512d..7f87ad6 100644
--- a/src/gpu/batches/GrAAStrokeRectBatch.cpp
+++ b/src/gpu/batches/GrAAStrokeRectBatch.cpp
@@ -152,6 +152,26 @@
 
     const char* name() const override { return "AAStrokeRect"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x, ORect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], "
+                           "AssistORect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], "
+                           "IRect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], Degen: %d",
+                           geo.fColor,
+                           geo.fDevOutside.fLeft, geo.fDevOutside.fTop,
+                           geo.fDevOutside.fRight, geo.fDevOutside.fBottom,
+                           geo.fDevOutsideAssist.fLeft, geo.fDevOutsideAssist.fTop,
+                           geo.fDevOutsideAssist.fRight, geo.fDevOutsideAssist.fBottom,
+                           geo.fDevInside.fLeft, geo.fDevInside.fTop,
+                           geo.fDevInside.fRight, geo.fDevInside.fBottom,
+                           geo.fDegenerate);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrAnalyticRectBatch.cpp b/src/gpu/batches/GrAnalyticRectBatch.cpp
index fb343df..655644f 100644
--- a/src/gpu/batches/GrAnalyticRectBatch.cpp
+++ b/src/gpu/batches/GrAnalyticRectBatch.cpp
@@ -270,6 +270,7 @@
                            fGeoData[i].fHalfWidth,
                            fGeoData[i].fHalfHeight);
         }
+        string.append(DumpPipelineInfo(*this->pipeline()));
         string.append(INHERITED::dumpInfo());
         return string;
     }
diff --git a/src/gpu/batches/GrAtlasTextBatch.cpp b/src/gpu/batches/GrAtlasTextBatch.cpp
index fe5c3b9..cf4ca24 100644
--- a/src/gpu/batches/GrAtlasTextBatch.cpp
+++ b/src/gpu/batches/GrAtlasTextBatch.cpp
@@ -40,6 +40,7 @@
                     fGeoData[i].fBlob->runCount());
     }
 
+    str.append(DumpPipelineInfo(*this->pipeline()));
     str.append(INHERITED::dumpInfo());
     return str;
 }
diff --git a/src/gpu/batches/GrDefaultPathRenderer.cpp b/src/gpu/batches/GrDefaultPathRenderer.cpp
index 2fbc90b..21e2289 100644
--- a/src/gpu/batches/GrDefaultPathRenderer.cpp
+++ b/src/gpu/batches/GrDefaultPathRenderer.cpp
@@ -113,6 +113,16 @@
 
     const char* name() const override { return "DefaultPathBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x Tolerance: %.2f\n", geo.fColor, geo.fTolerance);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrDrawAtlasBatch.h b/src/gpu/batches/GrDrawAtlasBatch.h
index d9adf22..f8d88e0 100644
--- a/src/gpu/batches/GrDrawAtlasBatch.h
+++ b/src/gpu/batches/GrDrawAtlasBatch.h
@@ -21,6 +21,16 @@
 
     const char* name() const override { return "DrawAtlasBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Color: 0x%08x, Quads: %d\n", geo.fColor, geo.fVerts.count() / 4);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrDrawBatch.h b/src/gpu/batches/GrDrawBatch.h
index 95516c9..c92dca3 100644
--- a/src/gpu/batches/GrDrawBatch.h
+++ b/src/gpu/batches/GrDrawBatch.h
@@ -75,40 +75,38 @@
         return this->pipeline()->getRenderTarget()->uniqueID();
     }
 
-    SkString dumpInfo() const override {
+protected:
+    static SkString DumpPipelineInfo(const GrPipeline& pipeline) {
         SkString string;
-        string.appendf("RT: %d\n", this->renderTargetUniqueID().asUInt());
+        string.appendf("RT: %d\n", pipeline.getRenderTarget()->uniqueID().asUInt());
         string.append("ColorStages:\n");
-        for (int i = 0; i < this->pipeline()->numColorFragmentProcessors(); i++) {
+        for (int i = 0; i < pipeline.numColorFragmentProcessors(); i++) {
             string.appendf("\t\t%s\n\t\t%s\n",
-                           this->pipeline()->getColorFragmentProcessor(i).name(),
-                           this->pipeline()->getColorFragmentProcessor(i).dumpInfo().c_str());
+                           pipeline.getColorFragmentProcessor(i).name(),
+                           pipeline.getColorFragmentProcessor(i).dumpInfo().c_str());
         }
         string.append("CoverageStages:\n");
-        for (int i = 0; i < this->pipeline()->numCoverageFragmentProcessors(); i++) {
+        for (int i = 0; i < pipeline.numCoverageFragmentProcessors(); i++) {
             string.appendf("\t\t%s\n\t\t%s\n",
-                           this->pipeline()->getCoverageFragmentProcessor(i).name(),
-                           this->pipeline()->getCoverageFragmentProcessor(i).dumpInfo().c_str());
+                           pipeline.getCoverageFragmentProcessor(i).name(),
+                           pipeline.getCoverageFragmentProcessor(i).dumpInfo().c_str());
         }
-        string.appendf("XP: %s\n", this->pipeline()->getXferProcessor().name());
+        string.appendf("XP: %s\n", pipeline.getXferProcessor().name());
 
-        bool scissorEnabled = this->pipeline()->getScissorState().enabled();
+        bool scissorEnabled = pipeline.getScissorState().enabled();
         string.appendf("Scissor: ");
         if (scissorEnabled) {
             string.appendf("[L: %d, T: %d, R: %d, B: %d]\n",
-                           this->pipeline()->getScissorState().rect().fLeft,
-                           this->pipeline()->getScissorState().rect().fTop,
-                           this->pipeline()->getScissorState().rect().fRight,
-                           this->pipeline()->getScissorState().rect().fBottom);
+                           pipeline.getScissorState().rect().fLeft,
+                           pipeline.getScissorState().rect().fTop,
+                           pipeline.getScissorState().rect().fRight,
+                           pipeline.getScissorState().rect().fBottom);
         } else {
             string.appendf("<disabled>\n");
         }
-        string.append(INHERITED::dumpInfo());
-
         return string;
     }
 
-protected:
     const GrPipeline* pipeline() const {
         SkASSERT(fPipelineInstalled);
         return reinterpret_cast<const GrPipeline*>(fPipelineStorage.get());
diff --git a/src/gpu/batches/GrDrawPathBatch.cpp b/src/gpu/batches/GrDrawPathBatch.cpp
index 6522fb5..fb458ec 100644
--- a/src/gpu/batches/GrDrawPathBatch.cpp
+++ b/src/gpu/batches/GrDrawPathBatch.cpp
@@ -22,6 +22,7 @@
 SkString GrDrawPathBatch::dumpInfo() const {
     SkString string;
     string.printf("PATH: 0x%p", fPath.get());
+    string.append(DumpPipelineInfo(*this->pipeline()));
     string.append(INHERITED::dumpInfo());
     return string;
 }
@@ -44,6 +45,7 @@
     }
     string.remove(string.size() - 2, 2);
     string.append("]");
+    string.append(DumpPipelineInfo(*this->pipeline()));
     string.append(INHERITED::dumpInfo());
     return string;
 }
diff --git a/src/gpu/batches/GrDrawVerticesBatch.h b/src/gpu/batches/GrDrawVerticesBatch.h
index 9665c1a..d71fb0d 100644
--- a/src/gpu/batches/GrDrawVerticesBatch.h
+++ b/src/gpu/batches/GrDrawVerticesBatch.h
@@ -31,6 +31,15 @@
 
     const char* name() const override { return "DrawVerticesBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.appendf("PrimType: %d, VarColor: %d, VCount: %d, ICount: %d\n",
+                       fPrimitiveType, fVariableColor, fVertexCount, fIndexCount);
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override;
diff --git a/src/gpu/batches/GrMSAAPathRenderer.cpp b/src/gpu/batches/GrMSAAPathRenderer.cpp
index a1fc635..ab98a15 100644
--- a/src/gpu/batches/GrMSAAPathRenderer.cpp
+++ b/src/gpu/batches/GrMSAAPathRenderer.cpp
@@ -233,6 +233,17 @@
 
     const char* name() const override { return "MSAAPathBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.appendf("Indexed: %d\n", fIsIndexed);
+        for (const auto& path : fPaths) {
+            string.appendf("Color: 0x%08x\n", path.fColor);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrNinePatch.cpp b/src/gpu/batches/GrNinePatch.cpp
index 5e0be73..2e1809d 100644
--- a/src/gpu/batches/GrNinePatch.cpp
+++ b/src/gpu/batches/GrNinePatch.cpp
@@ -59,6 +59,7 @@
                         fPatches[i].fDst.fRight, fPatches[i].fDst.fBottom);
         }
 
+        str.append(DumpPipelineInfo(*this->pipeline()));
         str.append(INHERITED::dumpInfo());
         return str;
     }
diff --git a/src/gpu/batches/GrNonAAFillRectBatch.cpp b/src/gpu/batches/GrNonAAFillRectBatch.cpp
index cc89d03..0e66134 100644
--- a/src/gpu/batches/GrNonAAFillRectBatch.cpp
+++ b/src/gpu/batches/GrNonAAFillRectBatch.cpp
@@ -107,6 +107,7 @@
                         i, info.fColor,
                         info.fRect.fLeft, info.fRect.fTop, info.fRect.fRight, info.fRect.fBottom);
         }
+        str.append(DumpPipelineInfo(*this->pipeline()));
         str.append(INHERITED::dumpInfo());
         return str;
     }
diff --git a/src/gpu/batches/GrNonAAFillRectPerspectiveBatch.cpp b/src/gpu/batches/GrNonAAFillRectPerspectiveBatch.cpp
index 0652580..9a946c8 100644
--- a/src/gpu/batches/GrNonAAFillRectPerspectiveBatch.cpp
+++ b/src/gpu/batches/GrNonAAFillRectPerspectiveBatch.cpp
@@ -125,6 +125,7 @@
                         i, geo.fColor,
                         geo.fRect.fLeft, geo.fRect.fTop, geo.fRect.fRight, geo.fRect.fBottom);
         }
+        str.append(DumpPipelineInfo(*this->pipeline()));
         str.append(INHERITED::dumpInfo());
         return str;
     }
diff --git a/src/gpu/batches/GrNonAAStrokeRectBatch.cpp b/src/gpu/batches/GrNonAAStrokeRectBatch.cpp
index f443b32..9139dab 100644
--- a/src/gpu/batches/GrNonAAStrokeRectBatch.cpp
+++ b/src/gpu/batches/GrNonAAStrokeRectBatch.cpp
@@ -51,6 +51,17 @@
 
     const char* name() const override { return "NonAAStrokeRectBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.appendf("Color: 0x%08x, Rect [L: %.2f, T: %.2f, R: %.2f, B: %.2f], "
+                       "StrokeWidth: %.2f\n",
+                       fColor, fRect.fLeft, fRect.fTop, fRect.fRight, fRect.fBottom,
+                       fStrokeWidth);
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/batches/GrPLSPathRenderer.cpp b/src/gpu/batches/GrPLSPathRenderer.cpp
index a41e140..f31c323 100644
--- a/src/gpu/batches/GrPLSPathRenderer.cpp
+++ b/src/gpu/batches/GrPLSPathRenderer.cpp
@@ -778,6 +778,14 @@
 
     const char* name() const override { return "PLSBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.printf("Color 0x%08x, UsesLocalCoords: %d\n", fColor, fUsesLocalCoords);
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
@@ -927,8 +935,7 @@
     SkPath path;
     args.fShape->asPath(&path);
 
-    sk_sp<GrDrawBatch> batch(new PLSPathBatch(args.fPaint->getColor(),
-                                              path, *args.fViewMatrix));
+    sk_sp<GrDrawBatch> batch(new PLSPathBatch(args.fPaint->getColor(), path, *args.fViewMatrix));
 
     GrPipelineBuilder pipelineBuilder(*args.fPaint,
                                       args.fRenderTargetContext->mustUseHWAA(*args.fPaint));
diff --git a/src/gpu/batches/GrRegionBatch.cpp b/src/gpu/batches/GrRegionBatch.cpp
index 47b6f67..ae09a5f 100644
--- a/src/gpu/batches/GrRegionBatch.cpp
+++ b/src/gpu/batches/GrRegionBatch.cpp
@@ -76,6 +76,7 @@
             str.appendf("%d: Color: 0x%08x, Region with %d rects\n",
                         i, info.fColor, info.fRegion.computeRegionComplexity());
         }
+        str.append(DumpPipelineInfo(*this->pipeline()));
         str.append(INHERITED::dumpInfo());
         return str;
     }
diff --git a/src/gpu/batches/GrShadowRRectBatch.cpp b/src/gpu/batches/GrShadowRRectBatch.cpp
index 08f7e86..c4b56b8 100755
--- a/src/gpu/batches/GrShadowRRectBatch.cpp
+++ b/src/gpu/batches/GrShadowRRectBatch.cpp
@@ -143,6 +143,7 @@
                            fGeoData[i].fOuterRadius, fGeoData[i].fInnerRadius,
                            fGeoData[i].fBlurRadius);
         }
+        string.append(DumpPipelineInfo(*this->pipeline()));
         string.append(INHERITED::dumpInfo());
         return string;
     }
@@ -574,6 +575,7 @@
                            fGeoData[i].fOuterRadius, fGeoData[i].fInnerRadius,
                            fGeoData[i].fBlurRadius);
         }
+        string.append(DumpPipelineInfo(*this->pipeline()));
         string.append(INHERITED::dumpInfo());
         return string;
     }
diff --git a/src/gpu/batches/GrTessellatingPathRenderer.cpp b/src/gpu/batches/GrTessellatingPathRenderer.cpp
index 8e17ea4..970af5c 100644
--- a/src/gpu/batches/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/batches/GrTessellatingPathRenderer.cpp
@@ -174,6 +174,14 @@
 
     const char* name() const override { return "TessellatingPathBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        string.appendf("Color 0x%08x, aa: %d\n", fColor, fAntiAlias);
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/effects/GrDashingEffect.cpp b/src/gpu/effects/GrDashingEffect.cpp
index 669e604..d9cb72f 100644
--- a/src/gpu/effects/GrDashingEffect.cpp
+++ b/src/gpu/effects/GrDashingEffect.cpp
@@ -260,6 +260,23 @@
 
     const char* name() const override { return "DashBatch"; }
 
+    SkString dumpInfo() const override {
+        SkString string;
+        for (const auto& geo : fGeoData) {
+            string.appendf("Pt0: [%.2f, %.2f], Pt1: [%.2f, %.2f], Width: %.2f, Ival0: %.2f, "
+                           "Ival1 : %.2f, Phase: %.2f\n",
+                           geo.fPtsRot[0].fX, geo.fPtsRot[0].fY,
+                           geo.fPtsRot[1].fX, geo.fPtsRot[1].fY,
+                           geo.fSrcStrokeWidth,
+                           geo.fIntervals[0],
+                           geo.fIntervals[1],
+                           geo.fPhase);
+        }
+        string.append(DumpPipelineInfo(*this->pipeline()));
+        string.append(INHERITED::dumpInfo());
+        return string;
+    }
+
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h
index 97d6e19..faa5471 100644
--- a/src/gpu/instanced/InstancedRendering.h
+++ b/src/gpu/instanced/InstancedRendering.h
@@ -100,6 +100,25 @@
         ~Batch() override;
         const char* name() const override { return "Instanced Batch"; }
 
+        SkString dumpInfo() const override {
+            SkString string;
+            string.printf("AA: %d, ShapeTypes: 0x%02x, IShapeTypes: 0x%02x, Persp %d, "
+                          "NonSquare: %d, PLoad: %0.2f, Tracked: %d, NumDraws: %d, "
+                          "GeomChanges: %d\n",
+                          (int)fInfo.fAntialiasMode,
+                          fInfo.fShapeTypes,
+                          fInfo.fInnerShapeTypes,
+                          fInfo.fHasPerspective,
+                          fInfo.fNonSquare,
+                          fPixelLoad,
+                          fIsTracked,
+                          fNumDraws,
+                          fNumChangesInGeometry);
+            string.append(DumpPipelineInfo(*this->pipeline()));
+            string.append(INHERITED::dumpInfo());
+            return string;
+        }
+
         struct Draw {
             Instance     fInstance;
             IndexRange   fGeometry;