xref: /aosp_15_r20/external/skia/tools/debugger/DrawCommand.h (revision c8dee2aa9b3f27cf6c858bd81872bdeb2c07ed17) 
1 /*
2  * Copyright 2012 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #ifndef SKDRAWCOMMAND_H_
9 #define SKDRAWCOMMAND_H_
10 
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkData.h"
14 #include "include/core/SkDrawable.h"
15 #include "include/core/SkImage.h"
16 #include "include/core/SkImageFilter.h"
17 #include "include/core/SkM44.h"
18 #include "include/core/SkMatrix.h"
19 #include "include/core/SkPaint.h"
20 #include "include/core/SkPath.h"
21 #include "include/core/SkPicture.h"
22 #include "include/core/SkPoint.h"
23 #include "include/core/SkRRect.h"
24 #include "include/core/SkRect.h"
25 #include "include/core/SkRefCnt.h"
26 #include "include/core/SkRegion.h"
27 #include "include/core/SkSamplingOptions.h"
28 #include "include/core/SkScalar.h"
29 #include "include/core/SkShader.h"
30 #include "include/core/SkString.h"
31 #include "include/core/SkTextBlob.h"
32 #include "include/core/SkTypes.h"
33 #include "include/core/SkVertices.h"
34 #include "include/private/base/SkTDArray.h"
35 #include "include/private/base/SkTemplates.h"
36 #include "src/base/SkTLazy.h"
37 #include "src/core/SkDrawShadowInfo.h"
38 
39 #include <cstddef>
40 #include <cstdint>
41 
42 class DebugLayerManager;
43 class SkBitmap;
44 class SkFlattenable;
45 class SkJSONWriter;
46 class SkWStream;
47 class UrlDataManager;
48 enum class SkBlendMode;
49 enum class SkClipOp;
50 struct SkPoint3;
51 struct SkRSXform;
52 
53 class DrawCommand {
54 public:
55     enum OpType {
56         kBeginDrawPicture_OpType,
57         kClear_OpType,
58         kClipPath_OpType,
59         kClipRegion_OpType,
60         kClipRect_OpType,
61         kClipRRect_OpType,
62         kClipShader_OpType,
63         kResetClip_OpType,
64         kConcat_OpType,
65         kConcat44_OpType,
66         kDrawAnnotation_OpType,
67         kDrawBitmap_OpType,
68         kDrawBitmapRect_OpType,
69         kDrawDRRect_OpType,
70         kDrawImage_OpType,
71         kDrawImageLattice_OpType,
72         kDrawImageRect_OpType,
73         kDrawImageRectLayer_OpType, // unique to DebugCanvas
74         kDrawOval_OpType,
75         kDrawArc_OpType,
76         kDrawPaint_OpType,
77         kDrawPatch_OpType,
78         kDrawPath_OpType,
79         kDrawPoints_OpType,
80         kDrawRect_OpType,
81         kDrawRRect_OpType,
82         kDrawRegion_OpType,
83         kDrawShadow_OpType,
84         kDrawTextBlob_OpType,
85         kDrawVertices_OpType,
86         kDrawAtlas_OpType,
87         kDrawDrawable_OpType,
88         kDrawEdgeAAQuad_OpType,
89         kDrawEdgeAAImageSet_OpType,
90         kEndDrawPicture_OpType,
91         kRestore_OpType,
92         kSave_OpType,
93         kSaveLayer_OpType,
94         kSetMatrix_OpType,
95         kSetM44_OpType,
96 
97         kLast_OpType = kSetM44_OpType
98     };
99 
100     static const int kOpTypeCount = kLast_OpType + 1;
101 
102     static void WritePNG(const SkBitmap& bitmap, SkWStream& out);
103 
104     DrawCommand(OpType opType);
105 
~DrawCommand()106     virtual ~DrawCommand() {}
107 
isVisible()108     bool isVisible() const { return fVisible; }
109 
setVisible(bool toggle)110     void setVisible(bool toggle) { fVisible = toggle; }
111 
112     virtual void execute(SkCanvas*) const = 0;
113 
render(SkCanvas * canvas)114     virtual bool render(SkCanvas* canvas) const { return false; }
115 
116     virtual void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const;
117 
118     static const char* GetCommandString(OpType type);
119 
120     // Helper methods for converting things to JSON
121     static void MakeJsonColor(SkJSONWriter&, const SkColor color);
122     static void MakeJsonColor4f(SkJSONWriter&, const SkColor4f& color);
123     static void MakeJsonPoint(SkJSONWriter&, const SkPoint& point);
124     static void MakeJsonPoint(SkJSONWriter&, SkScalar x, SkScalar y);
125     static void MakeJsonPoint3(SkJSONWriter&, const SkPoint3& point);
126     static void MakeJsonRect(SkJSONWriter&, const SkRect& rect);
127     static void MakeJsonIRect(SkJSONWriter&, const SkIRect&);
128     static void MakeJsonMatrix(SkJSONWriter&, const SkMatrix&);
129     static void MakeJsonMatrix44(SkJSONWriter&, const SkM44&);
130     static void MakeJsonPath(SkJSONWriter&, const SkPath& path);
131     static void MakeJsonRegion(SkJSONWriter&, const SkRegion& region);
132     static void MakeJsonSampling(SkJSONWriter&, const SkSamplingOptions& sampling);
133     static void MakeJsonPaint(SkJSONWriter&, const SkPaint& paint, UrlDataManager& urlDataManager);
134     static void MakeJsonLattice(SkJSONWriter&, const SkCanvas::Lattice& lattice);
135 
136     static void flatten(const SkFlattenable* flattenable,
137                         SkJSONWriter&        writer,
138                         UrlDataManager&      urlDataManager);
139     static bool flatten(const SkImage& image, SkJSONWriter& writer, UrlDataManager& urlDataManager);
140     static bool flatten(const SkBitmap& bitmap,
141                         SkJSONWriter&   writer,
142                         UrlDataManager& urlDataManager);
getOpType()143     OpType getOpType() const { return fOpType; }
144 
145 private:
146     OpType fOpType;
147     bool   fVisible;
148 };
149 
150 class RestoreCommand : public DrawCommand {
151 public:
152     RestoreCommand();
153     void execute(SkCanvas* canvas) const override;
154 
155 private:
156     using INHERITED = DrawCommand;
157 };
158 
159 class ClearCommand : public DrawCommand {
160 public:
161     ClearCommand(SkColor color);
162     void execute(SkCanvas* canvas) const override;
163     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
164 
165 private:
166     SkColor fColor;
167 
168     using INHERITED = DrawCommand;
169 };
170 
171 class ClipPathCommand : public DrawCommand {
172 public:
173     ClipPathCommand(const SkPath& path, SkClipOp op, bool doAA);
174     void execute(SkCanvas* canvas) const override;
175     bool render(SkCanvas* canvas) const override;
176     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
177 
178 private:
179     SkPath   fPath;
180     SkClipOp fOp;
181     bool     fDoAA;
182 
183     using INHERITED = DrawCommand;
184 };
185 
186 class ClipRegionCommand : public DrawCommand {
187 public:
188     ClipRegionCommand(const SkRegion& region, SkClipOp op);
189     void execute(SkCanvas* canvas) const override;
190     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
191 
192 private:
193     SkRegion fRegion;
194     SkClipOp fOp;
195 
196     using INHERITED = DrawCommand;
197 };
198 
199 class ClipRectCommand : public DrawCommand {
200 public:
201     ClipRectCommand(const SkRect& rect, SkClipOp op, bool doAA);
202     void execute(SkCanvas* canvas) const override;
203     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
204 
205 private:
206     SkRect   fRect;
207     SkClipOp fOp;
208     bool     fDoAA;
209 
210     using INHERITED = DrawCommand;
211 };
212 
213 class ClipRRectCommand : public DrawCommand {
214 public:
215     ClipRRectCommand(const SkRRect& rrect, SkClipOp op, bool doAA);
216     void execute(SkCanvas* canvas) const override;
217     bool render(SkCanvas* canvas) const override;
218     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
219 
220 private:
221     SkRRect  fRRect;
222     SkClipOp fOp;
223     bool     fDoAA;
224 
225     using INHERITED = DrawCommand;
226 };
227 
228 class ClipShaderCommand : public DrawCommand {
229 public:
230     ClipShaderCommand(sk_sp<SkShader>, SkClipOp);
231     void execute(SkCanvas* canvas) const override;
232     bool render(SkCanvas* canvas) const override;
233     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
234 
235 private:
236     sk_sp<SkShader> fShader;
237     SkClipOp fOp;
238 
239     using INHERITED = DrawCommand;
240 };
241 
242 class ResetClipCommand : public DrawCommand {
243 public:
244     ResetClipCommand();
245     void execute(SkCanvas* canvas) const override;
246 
247 private:
248     using INHERITED = DrawCommand;
249 };
250 
251 class ConcatCommand : public DrawCommand {
252 public:
253     ConcatCommand(const SkMatrix& matrix);
254     void execute(SkCanvas* canvas) const override;
255     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
256 
257 private:
258     SkMatrix fMatrix;
259 
260     using INHERITED = DrawCommand;
261 };
262 
263 class Concat44Command : public DrawCommand {
264 public:
265     Concat44Command(const SkM44& matrix);
266     void execute(SkCanvas* canvas) const override;
267     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
268 
269 private:
270     SkM44 fMatrix;
271 
272     using INHERITED = DrawCommand;
273 };
274 
275 class DrawAnnotationCommand : public DrawCommand {
276 public:
277     DrawAnnotationCommand(const SkRect&, const char key[], sk_sp<SkData> value);
278     void execute(SkCanvas* canvas) const override;
279     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
280 
281 private:
282     SkRect        fRect;
283     SkString      fKey;
284     sk_sp<SkData> fValue;
285 
286     using INHERITED = DrawCommand;
287 };
288 
289 class DrawImageCommand : public DrawCommand {
290 public:
291     DrawImageCommand(const SkImage* image, SkScalar left, SkScalar top,
292                      const SkSamplingOptions&, const SkPaint* paint);
293     void execute(SkCanvas* canvas) const override;
294     bool render(SkCanvas* canvas) const override;
295     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
296     uint64_t imageId(UrlDataManager& udb) const;
297 
298 private:
299     sk_sp<const SkImage> fImage;
300     SkScalar             fLeft;
301     SkScalar             fTop;
302     SkSamplingOptions    fSampling;
303     SkTLazy<SkPaint>     fPaint;
304 
305     using INHERITED = DrawCommand;
306 };
307 
308 class DrawImageLatticeCommand : public DrawCommand {
309 public:
310     DrawImageLatticeCommand(const SkImage*           image,
311                             const SkCanvas::Lattice& lattice,
312                             const SkRect&            dst,
313                             SkFilterMode,
314                             const SkPaint*           paint);
315     void execute(SkCanvas* canvas) const override;
316     bool render(SkCanvas* canvas) const override;
317     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
318     uint64_t imageId(UrlDataManager& udb) const;
319 
320 private:
321     sk_sp<const SkImage> fImage;
322     SkCanvas::Lattice    fLattice;
323     SkRect               fDst;
324     SkFilterMode         fFilter;
325     SkTLazy<SkPaint>     fPaint;
326 
327     using INHERITED = DrawCommand;
328 };
329 
330 class DrawImageRectCommand : public DrawCommand {
331 public:
332     DrawImageRectCommand(const SkImage*              image,
333                          const SkRect&               src,
334                          const SkRect&               dst,
335                          const SkSamplingOptions&    sampling,
336                          const SkPaint*              paint,
337                          SkCanvas::SrcRectConstraint constraint);
338     void execute(SkCanvas* canvas) const override;
339     bool render(SkCanvas* canvas) const override;
340     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
341     uint64_t imageId(UrlDataManager& udm) const;
342 
343 private:
344     sk_sp<const SkImage>        fImage;
345     SkRect                      fSrc;
346     SkRect                      fDst;
347     SkSamplingOptions           fSampling;
348     SkTLazy<SkPaint>            fPaint;
349     SkCanvas::SrcRectConstraint fConstraint;
350 
351     using INHERITED = DrawCommand;
352 };
353 
354 // Command for resolving the deferred SkImage representing an android layer
355 // Functions like DrawImageRect except it uses the saved UrlDataManager to resolve the image
356 // at the time execute() is called.
357 class DrawImageRectLayerCommand : public DrawCommand {
358 public:
359     DrawImageRectLayerCommand(DebugLayerManager*          layerManager,
360                               const int                   nodeId,
361                               const int                   frame,
362                               const SkRect&               src,
363                               const SkRect&               dst,
364                               const SkSamplingOptions&    sampling,
365                               const SkPaint*              paint,
366                               SkCanvas::SrcRectConstraint constraint);
367     void execute(SkCanvas* canvas) const override;
368     bool render(SkCanvas* canvas) const override;
369     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
370 
371 private:
372     DebugLayerManager*          fLayerManager;
373     int                         fNodeId;
374     int                         fFrame;
375     SkRect                      fSrc;
376     SkRect                      fDst;
377     SkSamplingOptions           fSampling;
378     SkTLazy<SkPaint>            fPaint;
379     SkCanvas::SrcRectConstraint fConstraint;
380 
381     using INHERITED = DrawCommand;
382 };
383 
384 class DrawOvalCommand : public DrawCommand {
385 public:
386     DrawOvalCommand(const SkRect& oval, const SkPaint& paint);
387     void execute(SkCanvas* canvas) const override;
388     bool render(SkCanvas* canvas) const override;
389     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
390 
391 private:
392     SkRect  fOval;
393     SkPaint fPaint;
394 
395     using INHERITED = DrawCommand;
396 };
397 
398 class DrawArcCommand : public DrawCommand {
399 public:
400     DrawArcCommand(const SkRect&  oval,
401                    SkScalar       startAngle,
402                    SkScalar       sweepAngle,
403                    bool           useCenter,
404                    const SkPaint& paint);
405     void execute(SkCanvas* canvas) const override;
406     bool render(SkCanvas* canvas) const override;
407     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
408 
409 private:
410     SkRect   fOval;
411     SkScalar fStartAngle;
412     SkScalar fSweepAngle;
413     bool     fUseCenter;
414     SkPaint  fPaint;
415 
416     using INHERITED = DrawCommand;
417 };
418 
419 class DrawPaintCommand : public DrawCommand {
420 public:
421     DrawPaintCommand(const SkPaint& paint);
422     void execute(SkCanvas* canvas) const override;
423     bool render(SkCanvas* canvas) const override;
424     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
425 
426 private:
427     SkPaint fPaint;
428 
429     using INHERITED = DrawCommand;
430 };
431 
432 class DrawBehindCommand : public DrawCommand {
433 public:
434     DrawBehindCommand(const SkPaint& paint);
435     void execute(SkCanvas* canvas) const override;
436     bool render(SkCanvas* canvas) const override;
437     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
438 
439 private:
440     SkPaint fPaint;
441 
442     using INHERITED = DrawCommand;
443 };
444 
445 class DrawPathCommand : public DrawCommand {
446 public:
447     DrawPathCommand(const SkPath& path, const SkPaint& paint);
448     void execute(SkCanvas* canvas) const override;
449     bool render(SkCanvas* canvas) const override;
450     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
451 
452 private:
453     SkPath  fPath;
454     SkPaint fPaint;
455 
456     using INHERITED = DrawCommand;
457 };
458 
459 class BeginDrawPictureCommand : public DrawCommand {
460 public:
461     BeginDrawPictureCommand(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint);
462 
463     void execute(SkCanvas* canvas) const override;
464     bool render(SkCanvas* canvas) const override;
465 
466 private:
467     sk_sp<const SkPicture> fPicture;
468     SkTLazy<SkMatrix>      fMatrix;
469     SkTLazy<SkPaint>       fPaint;
470 
471     using INHERITED = DrawCommand;
472 };
473 
474 class EndDrawPictureCommand : public DrawCommand {
475 public:
476     EndDrawPictureCommand(bool restore);
477 
478     void execute(SkCanvas* canvas) const override;
479 
480 private:
481     bool fRestore;
482 
483     using INHERITED = DrawCommand;
484 };
485 
486 class DrawPointsCommand : public DrawCommand {
487 public:
488     DrawPointsCommand(SkCanvas::PointMode mode,
489                       size_t              count,
490                       const SkPoint       pts[],
491                       const SkPaint&      paint);
492     void execute(SkCanvas* canvas) const override;
493     bool render(SkCanvas* canvas) const override;
494     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
495 
496 private:
497     SkCanvas::PointMode fMode;
498     SkTDArray<SkPoint>  fPts;
499     SkPaint             fPaint;
500 
501     using INHERITED = DrawCommand;
502 };
503 
504 class DrawRegionCommand : public DrawCommand {
505 public:
506     DrawRegionCommand(const SkRegion& region, const SkPaint& paint);
507     void execute(SkCanvas* canvas) const override;
508     bool render(SkCanvas* canvas) const override;
509     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
510 
511 private:
512     SkRegion fRegion;
513     SkPaint  fPaint;
514 
515     using INHERITED = DrawCommand;
516 };
517 
518 class DrawTextBlobCommand : public DrawCommand {
519 public:
520     DrawTextBlobCommand(sk_sp<SkTextBlob> blob, SkScalar x, SkScalar y, const SkPaint& paint);
521 
522     void execute(SkCanvas* canvas) const override;
523     bool render(SkCanvas* canvas) const override;
524     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
525 
526 private:
527     sk_sp<SkTextBlob> fBlob;
528     SkScalar          fXPos;
529     SkScalar          fYPos;
530     SkPaint           fPaint;
531 
532     using INHERITED = DrawCommand;
533 };
534 
535 class DrawPatchCommand : public DrawCommand {
536 public:
537     DrawPatchCommand(const SkPoint  cubics[12],
538                      const SkColor  colors[4],
539                      const SkPoint  texCoords[4],
540                      SkBlendMode    bmode,
541                      const SkPaint& paint);
542     void execute(SkCanvas* canvas) const override;
543     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
544 
545 private:
546     SkPoint     fCubics[12];
547     SkColor*    fColorsPtr;
548     SkColor     fColors[4];
549     SkPoint*    fTexCoordsPtr;
550     SkPoint     fTexCoords[4];
551     SkBlendMode fBlendMode;
552     SkPaint     fPaint;
553 
554     using INHERITED = DrawCommand;
555 };
556 
557 class DrawRectCommand : public DrawCommand {
558 public:
559     DrawRectCommand(const SkRect& rect, const SkPaint& paint);
560     void execute(SkCanvas* canvas) const override;
561     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
562 
563 private:
564     SkRect  fRect;
565     SkPaint fPaint;
566 
567     using INHERITED = DrawCommand;
568 };
569 
570 class DrawRRectCommand : public DrawCommand {
571 public:
572     DrawRRectCommand(const SkRRect& rrect, const SkPaint& paint);
573     void execute(SkCanvas* canvas) const override;
574     bool render(SkCanvas* canvas) const override;
575     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
576 
577 private:
578     SkRRect fRRect;
579     SkPaint fPaint;
580 
581     using INHERITED = DrawCommand;
582 };
583 
584 class DrawDRRectCommand : public DrawCommand {
585 public:
586     DrawDRRectCommand(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint);
587     void execute(SkCanvas* canvas) const override;
588     bool render(SkCanvas* canvas) const override;
589     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
590 
591 private:
592     SkRRect fOuter;
593     SkRRect fInner;
594     SkPaint fPaint;
595 
596     using INHERITED = DrawCommand;
597 };
598 
599 class DrawVerticesCommand : public DrawCommand {
600 public:
601     DrawVerticesCommand(sk_sp<SkVertices>, SkBlendMode, const SkPaint&);
602 
603     void execute(SkCanvas* canvas) const override;
604 
605 private:
606     sk_sp<SkVertices> fVertices;
607     SkBlendMode       fBlendMode;
608     SkPaint           fPaint;
609 
610     using INHERITED = DrawCommand;
611 };
612 
613 class DrawAtlasCommand : public DrawCommand {
614 public:
615     DrawAtlasCommand(const SkImage*,
616                      const SkRSXform[],
617                      const SkRect[],
618                      const SkColor[],
619                      int,
620                      SkBlendMode,
621                      const SkSamplingOptions&,
622                      const SkRect*,
623                      const SkPaint*);
624 
625     void execute(SkCanvas* canvas) const override;
626 
627 private:
628     sk_sp<const SkImage> fImage;
629     SkTDArray<SkRSXform> fXform;
630     SkTDArray<SkRect>    fTex;
631     SkTDArray<SkColor>   fColors;
632     SkBlendMode          fBlendMode;
633     SkSamplingOptions    fSampling;
634     SkTLazy<SkRect>      fCull;
635     SkTLazy<SkPaint>     fPaint;
636 
637     using INHERITED = DrawCommand;
638 };
639 
640 class SaveCommand : public DrawCommand {
641 public:
642     SaveCommand();
643     void execute(SkCanvas* canvas) const override;
644 
645 private:
646     using INHERITED = DrawCommand;
647 };
648 
649 class SaveLayerCommand : public DrawCommand {
650 public:
651     SaveLayerCommand(const SkCanvas::SaveLayerRec&);
652     void execute(SkCanvas* canvas) const override;
653     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
654 
655 private:
656     SkTLazy<SkRect>            fBounds;
657     SkTLazy<SkPaint>           fPaint;
658     sk_sp<const SkImageFilter> fBackdrop;
659     uint32_t                   fSaveLayerFlags;
660     SkScalar                   fBackdropScale;
661     SkTileMode                 fBackdropTileMode;
662 
663     using INHERITED = DrawCommand;
664 };
665 
666 class SetMatrixCommand : public DrawCommand {
667 public:
668     SetMatrixCommand(const SkMatrix& matrix);
669     void execute(SkCanvas* canvas) const override;
670     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
671 
672 private:
673     SkMatrix fMatrix;
674 
675     using INHERITED = DrawCommand;
676 };
677 
678 class SetM44Command : public DrawCommand {
679 public:
680     SetM44Command(const SkM44& matrix);
681     void execute(SkCanvas* canvas) const override;
682     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
683 
684 private:
685     SkM44 fMatrix;
686 
687     using INHERITED = DrawCommand;
688 };
689 
690 class DrawShadowCommand : public DrawCommand {
691 public:
692     DrawShadowCommand(const SkPath& path, const SkDrawShadowRec& rec);
693     void execute(SkCanvas* canvas) const override;
694     bool render(SkCanvas* canvas) const override;
695     void toJSON(SkJSONWriter& writer, UrlDataManager& urlDataManager) const override;
696 
697 private:
698     SkPath          fPath;
699     SkDrawShadowRec fShadowRec;
700 
701     using INHERITED = DrawCommand;
702 };
703 
704 class DrawDrawableCommand : public DrawCommand {
705 public:
706     DrawDrawableCommand(SkDrawable*, const SkMatrix*);
707     void execute(SkCanvas* canvas) const override;
708 
709 private:
710     sk_sp<SkDrawable> fDrawable;
711     SkTLazy<SkMatrix> fMatrix;
712 
713     using INHERITED = DrawCommand;
714 };
715 
716 class DrawEdgeAAQuadCommand : public DrawCommand {
717 public:
718     DrawEdgeAAQuadCommand(const SkRect&         rect,
719                           const SkPoint         clip[4],
720                           SkCanvas::QuadAAFlags aa,
721                           const SkColor4f&      color,
722                           SkBlendMode           mode);
723     void execute(SkCanvas* canvas) const override;
724 
725 private:
726     SkRect                fRect;
727     SkPoint               fClip[4];
728     int                   fHasClip;
729     SkCanvas::QuadAAFlags fAA;
730     SkColor4f             fColor;
731     SkBlendMode           fMode;
732 
733     using INHERITED = DrawCommand;
734 };
735 
736 class DrawEdgeAAImageSetCommand : public DrawCommand {
737 public:
738     DrawEdgeAAImageSetCommand(const SkCanvas::ImageSetEntry[],
739                               int count,
740                               const SkPoint[],
741                               const SkMatrix[],
742                               const SkSamplingOptions&,
743                               const SkPaint*,
744                               SkCanvas::SrcRectConstraint);
745     void execute(SkCanvas* canvas) const override;
746 
747 private:
748     skia_private::AutoTArray<SkCanvas::ImageSetEntry> fSet;
749     int                                               fCount;
750     skia_private::AutoTArray<SkPoint>                 fDstClips;
751     skia_private::AutoTArray<SkMatrix>                fPreViewMatrices;
752     SkSamplingOptions                                 fSampling;
753     SkTLazy<SkPaint>                                  fPaint;
754     SkCanvas::SrcRectConstraint                       fConstraint;
755 
756     using INHERITED = DrawCommand;
757 };
758 #endif
759