DM: track a direct/indirect bit for each Sink too.

dm/DMSrcSink.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef DMSrcSink_DEFINED
 #define DMSrcSink_DEFINED
 
@@ skipping 35 matching lines @@
 
     const char* c_str() const { return fMsg.c_str(); }
     bool isEmpty() const { return fMsg.isEmpty(); }
     bool isFatal() const { return fFatal; }
 
 private:
     SkString fMsg;
     bool     fFatal;
 };
 
-enum SinkType { kGPU_SinkType, kVector_SinkType, kRaster_SinkType };
+struct SinkFlags {
+    enum { kNull, kGPU, kVector, kRaster } type;
+    enum { kDirect, kIndirect } approach;
+};
 
 struct Src {
     // All Srcs must be thread safe.
     virtual ~Src() {}
     virtual Error SK_WARN_UNUSED_RESULT draw(SkCanvas*) const = 0;
     virtual SkISize size() const = 0;
     virtual Name name() const = 0;
     virtual void modifyGrContextOptions(GrContextOptions* options) const {}
-    virtual bool veto(SinkType) const { return false; }
+    virtual bool veto(SinkFlags) const { return false; }
 };
 
 struct Sink {
     virtual ~Sink() {}
     // You may write to either the bitmap or stream.  If you write to log, we'll print that out.
     virtual Error SK_WARN_UNUSED_RESULT draw(const Src&, SkBitmap*, SkWStream*, SkString* log)
         const = 0;
     // Sinks in the same enclave (except kAnyThread_Enclave) will run serially on the same thread.
     virtual int enclave() const = 0;
 
     // File extension for the content draw() outputs, e.g. "png", "pdf".
     virtual const char* fileExtension() const  = 0;
+
+    virtual SinkFlags flags() const = 0;
 };
 
 enum { kAnyThread_Enclave, kGPU_Enclave };
 static const int kNumEnclaves = kGPU_Enclave + 1;
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 class GMSrc : public Src {
 public:
     explicit GMSrc(skiagm::GMRegistry::Factory);
@@ skipping 19 matching lines @@
     enum DstColorType {
         kGetFromCanvas_DstColorType,
         kIndex8_Always_DstColorType,
         kGrayscale_Always_DstColorType,
     };
     CodecSrc(Path, Mode, DstColorType, float);
 
     Error draw(SkCanvas*) const override;
     SkISize size() const override;
     Name name() const override;
-    bool veto(SinkType) const override;
+    bool veto(SinkFlags) const override;
 private:
     Path                   fPath;
     Mode                   fMode;
     DstColorType           fDstColorType;
     float                  fScale;
 };
 
 
 class ImageSrc : public Src {
 public:
     // divisor == 0 means decode the whole image
     // divisor > 0 means decode in subsets, dividing into a divisor x divisor grid.
     explicit ImageSrc(Path path, int divisor = 0);
 
     Error draw(SkCanvas*) const override;
     SkISize size() const override;
     Name name() const override;
-    bool veto(SinkType) const override;
+    bool veto(SinkFlags) const override;
 private:
     Path fPath;
     const int  fDivisor;
 };
 
 class SKPSrc : public Src {
 public:
     explicit SKPSrc(Path path);
 
     Error draw(SkCanvas*) const override;
     SkISize size() const override;
     Name name() const override;
 private:
     Path fPath;
 };
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 class NullSink : public Sink {
 public:
     NullSink() {}
 
     Error draw(const Src& src, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override { return kAnyThread_Enclave; }
     const char* fileExtension() const override { return ""; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kNull, SinkFlags::kDirect }; }
 };
 
 
 class GPUSink : public Sink {
 public:
     GPUSink(GrContextFactory::GLContextType, GrGLStandard, int samples, bool dfText, bool threaded);
 
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override;
     const char* fileExtension() const override { return "png"; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kGPU, SinkFlags::kDirect }; }
 private:
     GrContextFactory::GLContextType fContextType;
     GrGLStandard                    fGpuAPI;
     int                             fSampleCount;
     bool                            fUseDFText;
     bool                            fThreaded;
 };
 
 class PDFSink : public Sink {
 public:
     PDFSink();
 
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override { return kAnyThread_Enclave; }
     const char* fileExtension() const override { return "pdf"; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
 };
 
 class XPSSink : public Sink {
 public:
     XPSSink();
 
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override { return kAnyThread_Enclave; }
     const char* fileExtension() const override { return "xps"; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
 };
 
 class RasterSink : public Sink {
 public:
     explicit RasterSink(SkColorType);
 
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override { return kAnyThread_Enclave; }
     const char* fileExtension() const override { return "png"; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kRaster, SinkFlags::kDirect }; }
 private:
     SkColorType    fColorType;
 };
 
 class SKPSink : public Sink {
 public:
     SKPSink();
 
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override { return kAnyThread_Enclave; }
     const char* fileExtension() const override { return "skp"; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
 };
 
 class SVGSink : public Sink {
 public:
     SVGSink();
 
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
     int enclave() const override { return kAnyThread_Enclave; }
     const char* fileExtension() const override { return "svg"; }
+    SinkFlags flags() const override { return SinkFlags{ SinkFlags::kVector, SinkFlags::kDirect }; }
 };
 
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 class Via : public Sink {
 public:
     explicit Via(Sink* sink) : fSink(sink) {}
     const char* fileExtension() const override { return fSink->fileExtension(); }
     int               enclave() const override { return fSink->enclave(); }
+    SinkFlags flags() const override {
+        SinkFlags flags = fSink->flags();
+        flags.approach = SinkFlags::kIndirect;
+        return flags;
+    }
 protected:
     SkAutoTDelete<Sink> fSink;
 };
 
 class ViaMatrix : public Via {
 public:
     ViaMatrix(SkMatrix, Sink*);
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
 private:
     const SkMatrix fMatrix;
@@ skipping 48 matching lines @@
 
 class ViaTwice : public Via {
 public:
     explicit ViaTwice(Sink* sink) : Via(sink) {}
     Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
 };
 
 }  // namespace DM
 
 #endif//DMSrcSink_DEFINED