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