simplify code in SkRecords.h

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCodec.h"
 #include "SkCodecTools.h"
 #include "SkCommonFlags.h"
 #include "SkData.h"
 #include "SkDocument.h"
 #include "SkError.h"
 #include "SkFunction.h"
 #include "SkImageGenerator.h"
 #include "SkMultiPictureDraw.h"
 #include "SkNullCanvas.h"
 #include "SkOSFile.h"
 #include "SkPictureData.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
 #include "SkRecordDraw.h"
 #include "SkRecorder.h"
 #include "SkSVGCanvas.h"
+#include "SkScaledCodec.h"
 #include "SkScanlineDecoder.h"
 #include "SkStream.h"
+#include "SkTLogic.h"
 #include "SkXMLWriter.h"
-#include "SkScaledCodec.h"
 
 DEFINE_bool(multiPage, false, "For document-type backends, render the source"
             " into multiple pages");
 
 static bool lazy_decode_bitmap(const void* src, size_t size, SkBitmap* dst) {
     SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, size));
     return encoded && SkDEPRECATED_InstallDiscardablePixelRef(encoded, dst);
 }
 
 namespace DM {
@@ skipping 1164 matching lines @@
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 // This is like SkRecords::Draw, in that it plays back SkRecords ops into a Canvas.
 // Unlike SkRecords::Draw, it builds a single-op sub-picture out of each Draw-type op.
 // This is an only-slightly-exaggerated simluation of Blink's Slimming Paint pictures.
 struct DrawsAsSingletonPictures {
     SkCanvas* fCanvas;
     const SkDrawableList& fDrawables;
 
-    SK_CREATE_MEMBER_DETECTOR(paint);
-
     template <typename T>
     void draw(const T& op, SkCanvas* canvas) {
         // We must pass SkMatrix::I() as our initial matrix.
         // By default SkRecords::Draw() uses the canvas' matrix as its initial matrix,
         // which would have the funky effect of applying transforms over and over.
         SkRecords::Draw d(canvas, nullptr, fDrawables.begin(), fDrawables.count(), &SkMatrix::I());
         d(op);
     }
 
-    // Most things that have paints are Draw-type ops.  Create sub-pictures for each.
+    // Draws get their own picture.
     template <typename T>
-    SK_WHEN(HasMember_paint<T>, void) operator()(const T& op) {
+    SK_WHEN(T::kTags & SkRecords::kDraw_Tag, void) operator()(const T& op) {
         SkPictureRecorder rec;
         this->draw(op, rec.beginRecording(SkRect::MakeLargest()));
         SkAutoTUnref<SkPicture> pic(rec.endRecordingAsPicture());
         fCanvas->drawPicture(pic);
     }
 
-    // If you don't have a paint or are a SaveLayer, you're not a Draw-type op.
-    // We cannot make subpictures out of these because they affect state.  Draw them directly.
+    // We'll just issue non-draws directly.
     template <typename T>
-    SK_WHEN(!HasMember_paint<T>, void) operator()(const T& op) { this->draw(op, fCanvas); }
-    void operator()(const SkRecords::SaveLayer& op)            { this->draw(op, fCanvas); }
+    skstd::enable_if_t<!(T::kTags & SkRecords::kDraw_Tag), void> operator()(const T& op) {
+        this->draw(op, fCanvas);
+    }
 };
 
 // Record Src into a picture, then record it into a macro picture with a sub-picture for each draw.
 // Then play back that macro picture into our wrapped sink.
 Error ViaSingletonPictures::draw(
         const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
     auto size = src.size();
     return draw_to_canvas(fSink, bitmap, stream, log, size, [&](SkCanvas* canvas) -> Error {
         // Use low-level (Skia-private) recording APIs so we can read the SkRecord.
         SkRecord skr;
@@ skipping 19 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM