patch from issue 886233004 at patchset 40001 (http://crrev.com/886233004#ps40001)

dm/DMSrcSink.cpp

 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
 #include "SkDocument.h"
 #include "SkMultiPictureDraw.h"
 #include "SkOSFile.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
 #include "SkSVGDevice.h"
 #include "SkStream.h"
@@ skipping 113 matching lines @@
 
 SkISize SKPSrc::size() const {
     // This may be unnecessarily large.
     return kSKPViewport.roundOut().size();
 }
 
 Name SKPSrc::name() const { return SkOSPath::Basename(fPath.c_str()); }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
+DEFINE_bool(gpuStats, false, "Append GPU stats to the log for each GPU task?");
+
 GPUSink::GPUSink(GrContextFactory::GLContextType ct,
                  GrGLStandard api,
                  int samples,
                  bool dfText,
                  bool threaded)
     : fContextType(ct)
     , fGpuAPI(api)
     , fSampleCount(samples)
     , fUseDFText(dfText)
     , fThreaded(threaded) {}
 
 int GPUSink::enclave() const {
     return fThreaded ? kAnyThread_Enclave : kGPU_Enclave;
 }
 
-Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const {
+Error GPUSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString* log) const {
     GrContextFactory factory;
     const SkISize size = src.size();
     const SkImageInfo info =
         SkImageInfo::Make(size.width(), size.height(), kN32_SkColorType, kPremul_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(
             NewGpuSurface(&factory, fContextType, fGpuAPI, info, fSampleCount, fUseDFText));
     if (!surface) {
         return "Could not create a surface.";
     }
     SkCanvas* canvas = surface->getCanvas();
     Error err = src.draw(canvas);
     if (!err.isEmpty()) {
         return err;
     }
     canvas->flush();
+    if (FLAGS_gpuStats) {
+        canvas->getGrContext()->dumpCacheStats(log);
+        canvas->getGrContext()->dumpGpuStats(log);
+    }
     dst->allocPixels(info);
     canvas->readPixels(dst, 0,0);
     if (FLAGS_abandonGpuContext) {
         factory.abandonContexts();
     }
     return "";
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 PDFSink::PDFSink() {}
 
-Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const {
+Error PDFSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
     // Print the given DM:Src to a PDF, breaking on 8.5x11 pages.
     SkAutoTUnref<SkDocument> doc(SkDocument::CreatePDF(dst));
 
     int width  = src.size().width(),
         height = src.size().height();
 
     const int kLetterWidth  = 612,  // 8.5 * 72
               kLetterHeight = 792;  // 11 * 72
     const SkRect letter = SkRect::MakeWH(SkIntToScalar(kLetterWidth),
                                          SkIntToScalar(kLetterHeight));
@@ skipping 18 matching lines @@
     }
     doc->close();
     dst->flush();
     return "";
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SKPSink::SKPSink() {}
 
-Error SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const {
+Error SKPSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
     SkSize size;
     size = src.size();
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
     pic->serialize(dst);
     return "";
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SVGSink::SVGSink() {}
 
-Error SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst) const {
+Error SVGSink::draw(const Src& src, SkBitmap*, SkWStream* dst, SkString*) const {
     SkAutoTUnref<SkBaseDevice> device(SkSVGDevice::Create(src.size(), dst));
     SkCanvas canvas(device);
     return src.draw(&canvas);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 RasterSink::RasterSink(SkColorType colorType) : fColorType(colorType) {}
 
-Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*) const {
+Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) const {
     const SkISize size = src.size();
     // If there's an appropriate alpha type for this color type, use it, otherwise use premul.
     SkAlphaType alphaType = kPremul_SkAlphaType;
     (void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
 
     dst->allocPixels(SkImageInfo::Make(size.width(), size.height(), fColorType, alphaType));
     dst->eraseColor(SK_ColorTRANSPARENT);
     SkCanvas canvas(*dst);
     return src.draw(&canvas);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaMatrix::ViaMatrix(SkMatrix matrix, Sink* sink) : fMatrix(matrix), fSink(sink) {}
 
-Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaMatrix::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
     // We turn our arguments into a Src, then draw that Src into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const Src& fSrc;
         SkMatrix fMatrix;
         ProxySrc(const Src& src, SkMatrix matrix) : fSrc(src), fMatrix(matrix) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             canvas->concat(fMatrix);
             return fSrc.draw(canvas);
         }
         SkISize size() const SK_OVERRIDE { return fSrc.size(); }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src, fMatrix);
-    return fSink->draw(proxy, bitmap, stream);
+    return fSink->draw(proxy, bitmap, stream, log);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaPipe::ViaPipe(Sink* sink) : fSink(sink) {}
 
-Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
     // We turn ourselves into another Src that draws our argument into bitmap/stream via pipe.
     struct ProxySrc : public Src {
         const Src& fSrc;
         ProxySrc(const Src& src) : fSrc(src) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             SkISize size = this->size();
             PipeController controller(canvas, &SkImageDecoder::DecodeMemory);
             SkGPipeWriter pipe;
             const uint32_t kFlags = 0; // We mirror SkDeferredCanvas, which doesn't use any flags.
             return fSrc.draw(pipe.startRecording(&controller, kFlags, size.width(), size.height()));
         }
         SkISize size() const SK_OVERRIDE { return fSrc.size(); }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src);
-    return fSink->draw(proxy, bitmap, stream);
+    return fSink->draw(proxy, bitmap, stream, log);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaSerialization::ViaSerialization(Sink* sink) : fSink(sink) {}
 
-Error ViaSerialization::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaSerialization::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log)
+    const {
     // Record our Src into a picture.
     SkSize size;
     size = src.size();
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
     // Serialize it and then deserialize it.
     SkDynamicMemoryWStream wStream;
     pic->serialize(&wStream);
     SkAutoTDelete<SkStream> rStream(wStream.detachAsStream());
     SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rStream));
 
     // Turn that deserialized picture into a Src, draw it into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const SkPicture* fPic;
         const SkISize fSize;
         ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             canvas->drawPicture(fPic);
             return "";
         }
         SkISize size() const SK_OVERRIDE { return fSize; }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(deserialized, src.size());
-    return fSink->draw(proxy, bitmap, stream);
+    return fSink->draw(proxy, bitmap, stream, log);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink)
     : fW(w)
     , fH(h)
     , fFactory(factory)
     , fSink(sink) {}
 
-Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream) const {
+Error ViaTiles::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
     // Record our Src into a picture.
     SkSize size;
     size = src.size();
     SkPictureRecorder recorder;
     Error err = src.draw(recorder.beginRecording(size.width(), size.height(), fFactory.get()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
@@ skipping 34 matching lines @@
                     SkAutoTUnref<SkImage> image(surfaces[i+xTiles*j]->newImageSnapshot());
                     canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(j*fH));
                 }
             }
             surfaces.unrefAll();
             return "";
         }
         SkISize size() const SK_OVERRIDE { return fSize; }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(fW, fH, pic, src.size());
-    return fSink->draw(proxy, bitmap, stream);
+    return fSink->draw(proxy, bitmap, stream, log);
 }
 
 }  // namespace DM