07d2d5f2dcbaf4358e4123f9c4bfd8e83b7c25ea
[WebKit-https.git] / Source / WebCore / platform / graphics / displaylists / DisplayListItems.h
1 /*
2  * Copyright (C) 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef DisplayListItems_h
27 #define DisplayListItems_h
28
29 #include "FloatPoint.h"
30 #include "FloatRect.h"
31 #include "FloatRoundedRect.h"
32 #include "Font.h"
33 #include "GlyphBuffer.h"
34 #include "GraphicsContext.h"
35 #include "Image.h"
36 #include <wtf/RefCounted.h>
37 #include <wtf/TypeCasts.h>
38
39 #if USE(CG)
40 #include "GraphicsContextPlatformPrivateCG.h"
41 #endif
42
43 namespace WebCore {
44
45 class TextStream;
46 struct ImagePaintingOptions;
47
48 namespace DisplayList {
49
50 enum class ItemType {
51     Save,
52     Restore,
53     Translate,
54     Rotate,
55     Scale,
56     ConcatenateCTM,
57     SetState,
58     SetLineCap,
59     SetLineDash,
60     SetLineJoin,
61     SetMiterLimit,
62     ClearShadow,
63     Clip,
64     ClipOut,
65     ClipOutToPath,
66     ClipPath,
67     ClipConvexPolygon,
68     DrawGlyphs,
69     DrawImage,
70     DrawTiledImage,
71     DrawTiledScaledImage,
72 #if USE(CG) || USE(CAIRO)
73     DrawNativeImage,
74 #endif
75     DrawPattern,
76     DrawRect,
77     DrawLine,
78     DrawLinesForText,
79     DrawLineForDocumentMarker,
80     DrawEllipse,
81     DrawConvexPolygon,
82     DrawPath,
83     DrawFocusRingPath,
84     DrawFocusRingRects,
85     FillRect,
86     FillRectWithColor,
87     FillRectWithGradient,
88     FillCompositedRect,
89     FillRoundedRect,
90     FillRectWithRoundedHole,
91     FillPath,
92     FillEllipse,
93     StrokeRect,
94     StrokePath,
95     StrokeEllipse,
96     ClearRect,
97     BeginTransparencyLayer,
98     EndTransparencyLayer,
99 #if USE(CG)
100     ApplyStrokePattern, // FIXME: should not be a recorded item.
101     ApplyFillPattern, // FIXME: should not be a recorded item.
102 #endif
103     ApplyDeviceScaleFactor,
104 };
105
106 class Item : public RefCounted<Item> {
107 public:
108     Item() = delete;
109
110     Item(ItemType type)
111         : m_type(type)
112     {
113     }
114
115     virtual ~Item() { }
116
117     ItemType type() const
118     {
119         return m_type;
120     }
121
122     virtual void apply(GraphicsContext&) const = 0;
123
124     static constexpr bool isDisplayListItem = true;
125
126     virtual bool isDrawingItem() const { return false; }
127     
128     // A state item is one preserved by Save/Restore.
129     bool isStateItem() const
130     {
131         return isStateItemType(m_type);
132     }
133
134     static bool isStateItemType(ItemType itemType)
135     {
136         switch (itemType) {
137         case ItemType:: Translate:
138         case ItemType:: Rotate:
139         case ItemType:: Scale:
140         case ItemType:: ConcatenateCTM:
141         case ItemType:: SetState:
142         case ItemType:: SetLineCap:
143         case ItemType:: SetLineDash:
144         case ItemType:: SetLineJoin:
145         case ItemType:: SetMiterLimit:
146         case ItemType:: ClearShadow:
147             return true;
148         default:
149             return false;
150         }
151         return false;
152     }
153
154 #if !defined(NDEBUG) || !LOG_DISABLED
155     WTF::CString description() const;
156 #endif
157     static size_t sizeInBytes(const Item&);
158
159 private:
160     ItemType m_type;
161 };
162
163 class DrawingItem : public Item {
164 public:
165     DrawingItem(ItemType type)
166         : Item(type)
167     {
168     }
169
170     void setExtent(const FloatRect& r) { m_extent = r; }
171     const FloatRect& extent() const { return m_extent.value(); }
172
173     bool extentKnown() const { return static_cast<bool>(m_extent); }
174
175     // Return bounds of this drawing operation in local coordinates.
176     // Does not include effets of transform, shadow etc in the state.
177     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const { return Nullopt; }
178
179 private:
180     virtual bool isDrawingItem() const { return true; }
181
182     Optional<FloatRect> m_extent; // In base coordinates, taking shadows and transforms into account.
183 };
184
185 class Save : public Item {
186 public:
187     static Ref<Save> create()
188     {
189         return adoptRef(*new Save);
190     }
191
192     // Index in the display list of the corresponding Restore item. 0 if unmatched.
193     size_t restoreIndex() const { return m_restoreIndex; }
194     void setRestoreIndex(size_t index) { m_restoreIndex = index; }
195
196 private:
197     Save()
198         : Item(ItemType::Save)
199     {
200     }
201
202     virtual void apply(GraphicsContext&) const override;
203     
204     size_t m_restoreIndex { 0 };
205 };
206
207 class Restore : public Item {
208 public:
209     static Ref<Restore> create()
210     {
211         return adoptRef(*new Restore);
212     }
213
214 private:
215     Restore()
216         : Item(ItemType::Restore)
217     {
218     }
219
220     virtual void apply(GraphicsContext&) const override;
221 };
222
223 class Translate : public Item {
224 public:
225     static Ref<Translate> create(float x, float y)
226     {
227         return adoptRef(*new Translate(x, y));
228     }
229
230     float x() const { return m_x; }
231     float y() const { return m_y; }
232
233 private:
234     Translate(float x, float y)
235         : Item(ItemType::Translate)
236         , m_x(x)
237         , m_y(y)
238     {
239     }
240
241     virtual void apply(GraphicsContext&) const override;
242
243     float m_x;
244     float m_y;
245 };
246
247 class Rotate : public Item {
248 public:
249     static Ref<Rotate> create(float angleInRadians)
250     {
251         return adoptRef(*new Rotate(angleInRadians));
252     }
253
254     float angle() const { return m_angle; }
255
256 private:
257     Rotate(float angle)
258         : Item(ItemType::Rotate)
259         , m_angle(angle)
260     {
261     }
262
263     virtual void apply(GraphicsContext&) const override;
264
265     float m_angle; // In radians.
266 };
267
268 class Scale : public Item {
269 public:
270     static Ref<Scale> create(const FloatSize& size)
271     {
272         return adoptRef(*new Scale(size));
273     }
274
275     const FloatSize& amount() const { return m_size; }
276
277 private:
278     Scale(const FloatSize& size)
279         : Item(ItemType::Scale)
280         , m_size(size)
281     {
282     }
283
284     virtual void apply(GraphicsContext&) const override;
285
286     FloatSize m_size;
287 };
288
289 class ConcatenateCTM : public Item {
290 public:
291     static Ref<ConcatenateCTM> create(const AffineTransform& matrix)
292     {
293         return adoptRef(*new ConcatenateCTM(matrix));
294     }
295
296     const AffineTransform& transform() const { return m_transform; }
297
298 private:
299     ConcatenateCTM(const AffineTransform&);
300
301     virtual void apply(GraphicsContext&) const override;
302
303     AffineTransform m_transform;
304 };
305
306 class SetState : public Item {
307 public:
308     static Ref<SetState> create(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
309     {
310         return adoptRef(*new SetState(state, flags));
311     }
312     
313     const GraphicsContextStateChange& state() const { return m_state; }
314
315     void accumulate(const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
316
317     void accumulate(GraphicsContextState&) const;
318
319     static void applyState(GraphicsContext&, const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
320
321     static void dumpStateChanges(TextStream&, const GraphicsContextState&, GraphicsContextState::StateChangeFlags);
322 private:
323     SetState(const GraphicsContextState& state, GraphicsContextState::StateChangeFlags flags)
324         : Item(ItemType::SetState)
325         , m_state(state, flags)
326     {
327     }
328
329     virtual void apply(GraphicsContext&) const override;
330
331     GraphicsContextStateChange m_state;
332 };
333
334 class SetLineCap : public Item {
335 public:
336     static Ref<SetLineCap> create(LineCap lineCap)
337     {
338         return adoptRef(*new SetLineCap(lineCap));
339     }
340     
341     LineCap lineCap() const { return m_lineCap; }
342
343 private:
344     SetLineCap(LineCap lineCap)
345         : Item(ItemType::SetLineCap)
346         , m_lineCap(lineCap)
347     {
348     }
349
350     virtual void apply(GraphicsContext&) const override;
351
352     LineCap m_lineCap;
353 };
354
355 class SetLineDash : public Item {
356 public:
357     static Ref<SetLineDash> create(const DashArray& dashArray, float dashOffset)
358     {
359         return adoptRef(*new SetLineDash(dashArray, dashOffset));
360     }
361
362     const DashArray& dashArray() const { return m_dashArray; }
363     float dashOffset() const { return m_dashOffset; }
364
365 private:
366     SetLineDash(const DashArray& dashArray, float dashOffset)
367         : Item(ItemType::SetLineDash)
368         , m_dashArray(dashArray)
369         , m_dashOffset(dashOffset)
370     {
371     }
372
373     virtual void apply(GraphicsContext&) const override;
374
375     DashArray m_dashArray;
376     float m_dashOffset;
377 };
378
379 class SetLineJoin : public Item {
380 public:
381     static Ref<SetLineJoin> create(LineJoin lineJoin)
382     {
383         return adoptRef(*new SetLineJoin(lineJoin));
384     }
385     
386     LineJoin lineJoin() const { return m_lineJoin; }
387
388 private:
389     SetLineJoin(LineJoin lineJoin)
390         : Item(ItemType::SetLineJoin)
391         , m_lineJoin(lineJoin)
392     {
393     }
394
395     virtual void apply(GraphicsContext&) const override;
396
397     LineJoin m_lineJoin;
398 };
399
400 class SetMiterLimit : public Item {
401 public:
402     static Ref<SetMiterLimit> create(float limit)
403     {
404         return adoptRef(*new SetMiterLimit(limit));
405     }
406
407     float miterLimit() const { return m_miterLimit; }
408
409 private:
410     SetMiterLimit(float miterLimit)
411         : Item(ItemType::SetMiterLimit)
412         , m_miterLimit(miterLimit)
413     {
414     }
415
416     virtual void apply(GraphicsContext&) const override;
417
418     float m_miterLimit;
419 };
420
421 class ClearShadow : public Item {
422 public:
423     static Ref<ClearShadow> create()
424     {
425         return adoptRef(*new ClearShadow);
426     }
427
428 private:
429     ClearShadow()
430         : Item(ItemType::ClearShadow)
431     {
432     }
433
434     virtual void apply(GraphicsContext&) const override;
435 };
436
437 // FIXME: treat as DrawingItem?
438 class Clip : public Item {
439 public:
440     static Ref<Clip> create(const FloatRect& rect)
441     {
442         return adoptRef(*new Clip(rect));
443     }
444
445     FloatRect rect() const { return m_rect; }
446
447 private:
448     Clip(const FloatRect& rect)
449         : Item(ItemType::Clip)
450         , m_rect(rect)
451     {
452     }
453
454     virtual void apply(GraphicsContext&) const override;
455
456     FloatRect m_rect;
457 };
458
459 class ClipOut : public Item {
460 public:
461     static Ref<ClipOut> create(const FloatRect& rect)
462     {
463         return adoptRef(*new ClipOut(rect));
464     }
465
466     FloatRect rect() const { return m_rect; }
467
468 private:
469     ClipOut(const FloatRect& rect)
470         : Item(ItemType::ClipOut)
471         , m_rect(rect)
472     {
473     }
474
475     virtual void apply(GraphicsContext&) const override;
476
477     FloatRect m_rect;
478 };
479
480 class ClipOutToPath : public Item {
481 public:
482     static Ref<ClipOutToPath> create(const Path& path)
483     {
484         return adoptRef(*new ClipOutToPath(path));
485     }
486
487     const Path& path() const { return m_path; }
488
489 private:
490     ClipOutToPath(const Path& path)
491         : Item(ItemType::ClipOutToPath)
492         , m_path(path)
493     {
494     }
495
496     virtual void apply(GraphicsContext&) const override;
497
498     const Path m_path;
499 };
500
501 class ClipPath : public Item {
502 public:
503     static Ref<ClipPath> create(const Path& path, WindRule windRule)
504     {
505         return adoptRef(*new ClipPath(path, windRule));
506     }
507
508     const Path& path() const { return m_path; }
509     WindRule windRule() const { return m_windRule; }
510
511 private:
512     ClipPath(const Path& path, WindRule windRule)
513         : Item(ItemType::ClipPath)
514         , m_path(path)
515         , m_windRule(windRule)
516     {
517     }
518
519     virtual void apply(GraphicsContext&) const override;
520
521     const Path m_path;
522     WindRule m_windRule;
523 };
524
525 class ClipConvexPolygon : public Item {
526 public:
527     static Ref<ClipConvexPolygon> create(size_t numberOfPoints, const FloatPoint* points, bool antialiased)
528     {
529         return adoptRef(*new ClipConvexPolygon(numberOfPoints, points, antialiased));
530     }
531
532     const Vector<FloatPoint>& points() const { return m_points; }
533     bool antialias() const { return m_antialias; }
534
535 private:
536     ClipConvexPolygon(size_t numberOfPoints, const FloatPoint*, bool antialiased);
537
538     virtual void apply(GraphicsContext&) const override;
539
540     Vector<FloatPoint> m_points;
541     bool m_antialias;
542 };
543
544 class DrawGlyphs : public DrawingItem {
545 public:
546     static Ref<DrawGlyphs> create(const Font& font, const GlyphBufferGlyph* glyphs, const GlyphBufferAdvance* advances, unsigned count, const FloatPoint& blockLocation, const FloatSize& localAnchor, FontSmoothingMode smoothingMode)
547     {
548         return adoptRef(*new DrawGlyphs(font, glyphs, advances, count, blockLocation, localAnchor, smoothingMode));
549     }
550
551     const FloatPoint& blockLocation() const { return m_blockLocation; }
552     void setBlockLocation(const FloatPoint& blockLocation) { m_blockLocation = blockLocation; }
553
554     const FloatSize& localAnchor() const { return m_localAnchor; }
555
556     FloatPoint anchorPoint() const { return m_blockLocation + m_localAnchor; }
557
558     const Vector<GlyphBufferGlyph, 128>& glyphs() const { return m_glyphs; }
559
560 private:
561     DrawGlyphs(const Font&, const GlyphBufferGlyph*, const GlyphBufferAdvance*, unsigned count, const FloatPoint& blockLocation, const FloatSize& localAnchor, FontSmoothingMode);
562
563     void computeBounds();
564
565     virtual void apply(GraphicsContext&) const override;
566
567     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
568
569     GlyphBuffer generateGlyphBuffer() const;
570
571     Ref<Font> m_font;
572     Vector<GlyphBufferGlyph, 128> m_glyphs;
573     Vector<GlyphBufferAdvance, 128> m_advances;
574     FloatRect m_bounds;
575     FloatPoint m_blockLocation;
576     FloatSize m_localAnchor;
577     FontSmoothingMode m_smoothingMode;
578 };
579
580 class DrawImage : public DrawingItem {
581 public:
582     static Ref<DrawImage> create(Image& image, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& imagePaintingOptions)
583     {
584         return adoptRef(*new DrawImage(image, destination, source, imagePaintingOptions));
585     }
586
587     const Image& image() const { return m_image.get(); }
588     FloatRect source() const { return m_source; }
589     FloatRect destination() const { return m_destination; }
590
591 private:
592     DrawImage(Image&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&);
593
594     virtual void apply(GraphicsContext&) const override;
595
596     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
597
598     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
599     FloatRect m_destination;
600     FloatRect m_source;
601     ImagePaintingOptions m_imagePaintingOptions;
602 };
603
604 class DrawTiledImage : public DrawingItem {
605 public:
606     static Ref<DrawTiledImage> create(Image& image, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions& imagePaintingOptions)
607     {
608         return adoptRef(*new DrawTiledImage(image, destination, source, tileSize, spacing, imagePaintingOptions));
609     }
610
611     const Image& image() const { return m_image.get(); }
612     FloatPoint source() const { return m_source; }
613     FloatRect destination() const { return m_destination; }
614
615     FloatSize tileSize() const { return m_tileSize; }
616     FloatSize spacing() const { return m_spacing; }
617
618 private:
619     DrawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&);
620
621     virtual void apply(GraphicsContext&) const override;
622
623     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
624
625     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
626     FloatRect m_destination;
627     FloatPoint m_source;
628     FloatSize m_tileSize;
629     FloatSize m_spacing;
630     ImagePaintingOptions m_imagePaintingOptions;
631 };
632
633 class DrawTiledScaledImage : public DrawingItem {
634 public:
635     static Ref<DrawTiledScaledImage> create(Image& image, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions& imagePaintingOptions)
636     {
637         return adoptRef(*new DrawTiledScaledImage(image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions));
638     }
639
640     const Image& image() const { return m_image.get(); }
641     FloatRect source() const { return m_source; }
642     FloatRect destination() const { return m_destination; }
643
644 private:
645     DrawTiledScaledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&);
646
647     virtual void apply(GraphicsContext&) const override;
648
649     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
650
651     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
652     FloatRect m_destination;
653     FloatRect m_source;
654     FloatSize m_tileScaleFactor;
655     Image::TileRule m_hRule;
656     Image::TileRule m_vRule;
657     ImagePaintingOptions m_imagePaintingOptions;
658 };
659
660 #if USE(CG) || USE(CAIRO)
661 class DrawNativeImage : public DrawingItem {
662 public:
663     static Ref<DrawNativeImage> create(PassNativeImagePtr imagePtr, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator op, BlendMode blendMode, ImageOrientation orientation)
664     {
665         return adoptRef(*new DrawNativeImage(imagePtr, imageSize, destRect, srcRect, op, blendMode, orientation));
666     }
667
668     FloatRect source() const { return m_srcRect; }
669     FloatRect destination() const { return m_destination; }
670
671 private:
672     DrawNativeImage(PassNativeImagePtr, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientation);
673
674     virtual void apply(GraphicsContext&) const override;
675
676     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
677
678 #if USE(CG)
679     RetainPtr<CGImageRef> m_imagePtr;
680 #endif
681     FloatSize m_imageSize;
682     FloatRect m_destination;
683     FloatRect m_srcRect;
684 #if USE(CG)
685     CompositeOperator m_op;
686     BlendMode m_blendMode;
687 #endif
688     ImageOrientation m_orientation;
689 };
690 #endif
691
692 class DrawPattern : public DrawingItem {
693 public:
694     static Ref<DrawPattern> create(Image& image, const FloatRect& tileRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
695     {
696         return adoptRef(*new DrawPattern(image, tileRect, patternTransform, phase, spacing, op, destRect, blendMode));
697     }
698
699     const Image& image() const { return m_image.get(); }
700     const AffineTransform& patternTransform() const { return m_patternTransform; }
701     FloatRect tileRect() const { return m_tileRect; }
702     FloatRect destRect() const { return m_destination; }
703     FloatPoint phase() const { return m_phase; }
704     FloatSize spacing() const { return m_spacing; }
705
706 private:
707     DrawPattern(Image&, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, const FloatRect& destRect, BlendMode = BlendModeNormal);
708
709     virtual void apply(GraphicsContext&) const override;
710
711     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_destination; }
712
713     mutable Ref<Image> m_image; // FIXME: Drawing images can cause their animations to progress. This shouldn't have to be mutable.
714     AffineTransform m_patternTransform;
715     FloatRect m_tileRect;
716     FloatRect m_destination;
717     FloatPoint m_phase;
718     FloatSize m_spacing;
719     CompositeOperator m_op;
720     BlendMode m_blendMode;
721 };
722
723 // Is DrawingItem because the size of the transparency layer is implicitly the clip bounds.
724 class BeginTransparencyLayer : public DrawingItem {
725 public:
726     static Ref<BeginTransparencyLayer> create(float opacity)
727     {
728         return adoptRef(*new BeginTransparencyLayer(opacity));
729     }
730
731     float opacity() const { return m_opacity; }
732
733 private:
734     BeginTransparencyLayer(float opacity)
735         : DrawingItem(ItemType::BeginTransparencyLayer)
736         , m_opacity(opacity)
737     {
738     }
739
740     virtual void apply(GraphicsContext&) const override;
741
742     float m_opacity;
743 };
744
745 class EndTransparencyLayer : public DrawingItem {
746 public:
747     static Ref<EndTransparencyLayer> create()
748     {
749         return adoptRef(*new EndTransparencyLayer);
750     }
751
752 private:
753     EndTransparencyLayer()
754         : DrawingItem(ItemType::EndTransparencyLayer)
755     {
756     }
757
758     virtual void apply(GraphicsContext&) const override;
759 };
760
761 class DrawRect : public DrawingItem {
762 public:
763     static Ref<DrawRect> create(const FloatRect& rect, float borderThickness)
764     {
765         return adoptRef(*new DrawRect(rect, borderThickness));
766     }
767
768     FloatRect rect() const { return m_rect; }
769     float borderThickness() const { return m_borderThickness; }
770
771 private:
772     DrawRect(const FloatRect& rect, float borderThickness)
773         : DrawingItem(ItemType::DrawRect)
774         , m_rect(rect)
775         , m_borderThickness(borderThickness)
776     {
777     }
778
779     virtual void apply(GraphicsContext&) const override;
780     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
781
782     FloatRect m_rect;
783     float m_borderThickness;
784 };
785
786 class DrawLine : public DrawingItem {
787 public:
788     static Ref<DrawLine> create(const FloatPoint& point1, const FloatPoint& point2)
789     {
790         return adoptRef(*new DrawLine(point1, point2));
791     }
792
793     FloatPoint point1() const { return m_point1; }
794     FloatPoint point2() const { return m_point2; }
795
796 private:
797     DrawLine(const FloatPoint& point1, const FloatPoint& point2)
798         : DrawingItem(ItemType::DrawLine)
799         , m_point1(point1)
800         , m_point2(point2)
801     {
802     }
803
804     virtual void apply(GraphicsContext&) const override;
805     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
806
807     FloatPoint m_point1;
808     FloatPoint m_point2;
809 };
810
811 class DrawLinesForText : public DrawingItem {
812 public:
813     static Ref<DrawLinesForText> create(const FloatPoint& blockLocation, const FloatSize& localAnchor, const DashArray& widths, bool printing, bool doubleLines, float strokeWidth)
814     {
815         return adoptRef(*new DrawLinesForText(blockLocation, localAnchor, widths, printing, doubleLines, strokeWidth));
816     }
817
818     void setBlockLocation(const FloatPoint& blockLocation) { m_blockLocation = blockLocation; }
819     const FloatPoint& blockLocation() const { return m_blockLocation; }
820     const FloatSize& localAnchor() const { return m_localAnchor; }
821     FloatPoint point() const { return m_blockLocation + m_localAnchor; }
822     const DashArray& widths() const { return m_widths; }
823     bool isPrinting() const { return m_printing; }
824     bool doubleLines() const { return m_doubleLines; }
825
826 private:
827     DrawLinesForText(const FloatPoint& blockLocation, const FloatSize& localAnchor, const DashArray& widths, bool printing, bool doubleLines, float strokeWidth)
828         : DrawingItem(ItemType::DrawLinesForText)
829         , m_blockLocation(blockLocation)
830         , m_localAnchor(localAnchor)
831         , m_widths(widths)
832         , m_strokeWidth(strokeWidth)
833         , m_printing(printing)
834         , m_doubleLines(doubleLines)
835     {
836     }
837
838     virtual void apply(GraphicsContext&) const override;
839
840     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
841
842     FloatPoint m_blockLocation;
843     FloatSize m_localAnchor;
844     DashArray m_widths;
845     float m_strokeWidth;
846     bool m_printing;
847     bool m_doubleLines;
848 };
849
850 class DrawLineForDocumentMarker : public DrawingItem {
851 public:
852     static Ref<DrawLineForDocumentMarker> create(const FloatPoint& point, float width, GraphicsContext::DocumentMarkerLineStyle style)
853     {
854         return adoptRef(*new DrawLineForDocumentMarker(point, width, style));
855     }
856
857     FloatPoint point() const { return m_point; }
858     float width() const { return m_width; }
859
860 private:
861     DrawLineForDocumentMarker(const FloatPoint& point, float width, GraphicsContext::DocumentMarkerLineStyle style)
862         : DrawingItem(ItemType::DrawLineForDocumentMarker)
863         , m_point(point)
864         , m_width(width)
865         , m_style(style)
866     {
867     }
868
869     virtual void apply(GraphicsContext&) const override;
870
871     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
872
873     FloatPoint m_point;
874     float m_width;
875     GraphicsContext::DocumentMarkerLineStyle m_style;
876 };
877
878 class DrawEllipse : public DrawingItem {
879 public:
880     static Ref<DrawEllipse> create(const FloatRect& rect)
881     {
882         return adoptRef(*new DrawEllipse(rect));
883     }
884
885     FloatRect rect() const { return m_rect; }
886
887 private:
888     DrawEllipse(const FloatRect& rect)
889         : DrawingItem(ItemType::DrawEllipse)
890         , m_rect(rect)
891     {
892     }
893
894     virtual void apply(GraphicsContext&) const override;
895     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
896
897     FloatRect m_rect;
898 };
899
900 class DrawConvexPolygon : public DrawingItem {
901 public:
902     static Ref<DrawConvexPolygon> create(size_t numberOfPoints, const FloatPoint* points, bool antialiased)
903     {
904         return adoptRef(*new DrawConvexPolygon(numberOfPoints, points, antialiased));
905     }
906
907     const Vector<FloatPoint>& points() const { return m_points; }
908     bool antialiased() const { return m_antialiased; }
909
910 private:
911     DrawConvexPolygon(size_t numberOfPoints, const FloatPoint*, bool antialiased);
912
913     virtual void apply(GraphicsContext&) const override;
914     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
915
916     Vector<FloatPoint> m_points;
917     bool m_antialiased;
918 };
919
920 class DrawPath : public DrawingItem {
921 public:
922     static Ref<DrawPath> create(const Path& path)
923     {
924         return adoptRef(*new DrawPath(path));
925     }
926
927     const Path& path() const { return m_path; }
928
929 private:
930     DrawPath(const Path& path)
931         : DrawingItem(ItemType::DrawPath)
932         , m_path(path)
933     {
934     }
935
936     virtual void apply(GraphicsContext&) const override;
937
938     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_path.fastBoundingRect(); }
939
940     const Path m_path;
941 };
942
943 class DrawFocusRingPath : public DrawingItem {
944 public:
945     static Ref<DrawFocusRingPath> create(const Path& path, int width, int offset, const Color& color)
946     {
947         return adoptRef(*new DrawFocusRingPath(path, width, offset, color));
948     }
949
950     const Path& path() const { return m_path; }
951     int width() const { return m_width; }
952     int offset() const { return m_offset; }
953     Color color() const { return m_color; }
954
955 private:
956     DrawFocusRingPath(const Path& path, int width, int offset, const Color& color)
957         : DrawingItem(ItemType::DrawFocusRingPath)
958         , m_path(path)
959         , m_width(width)
960         , m_offset(offset)
961         , m_color(color)
962     {
963     }
964
965     virtual void apply(GraphicsContext&) const override;
966
967     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
968
969     const Path m_path;
970     int m_width;
971     int m_offset;
972     Color m_color;
973 };
974
975 class DrawFocusRingRects : public DrawingItem {
976 public:
977     static Ref<DrawFocusRingRects> create(const Vector<IntRect>& rects, int width, int offset, const Color& color)
978     {
979         return adoptRef(*new DrawFocusRingRects(rects, width, offset, color));
980     }
981
982     const Vector<IntRect> rects() const { return m_rects; }
983     int width() const { return m_width; }
984     int offset() const { return m_offset; }
985     Color color() const { return m_color; }
986
987 private:
988     DrawFocusRingRects(const Vector<IntRect>& rects, int width, int offset, const Color& color)
989         : DrawingItem(ItemType::DrawFocusRingRects)
990         , m_rects(rects)
991         , m_width(width)
992         , m_offset(offset)
993         , m_color(color)
994     {
995     }
996
997     virtual void apply(GraphicsContext&) const override;
998
999     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1000
1001     Vector<IntRect> m_rects;
1002     int m_width;
1003     int m_offset;
1004     Color m_color;
1005 };
1006
1007 class FillRect : public DrawingItem {
1008 public:
1009     static Ref<FillRect> create(const FloatRect& rect)
1010     {
1011         return adoptRef(*new FillRect(rect));
1012     }
1013
1014     FloatRect rect() const { return m_rect; }
1015
1016 private:
1017     FillRect(const FloatRect& rect)
1018         : DrawingItem(ItemType::FillRect)
1019         , m_rect(rect)
1020     {
1021     }
1022
1023     virtual void apply(GraphicsContext&) const override;
1024     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1025
1026     FloatRect m_rect;
1027 };
1028
1029 // FIXME: Make these inherit from FillRect proper.
1030 class FillRectWithColor : public DrawingItem {
1031 public:
1032     static Ref<FillRectWithColor> create(const FloatRect& rect, const Color& color)
1033     {
1034         return adoptRef(*new FillRectWithColor(rect, color));
1035     }
1036
1037     FloatRect rect() const { return m_rect; }
1038     Color color() const { return m_color; }
1039
1040 private:
1041     FillRectWithColor(const FloatRect& rect, const Color& color)
1042         : DrawingItem(ItemType::FillRectWithColor)
1043         , m_rect(rect)
1044         , m_color(color)
1045     {
1046     }
1047
1048     virtual void apply(GraphicsContext&) const override;
1049     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1050
1051     FloatRect m_rect;
1052     Color m_color;
1053 };
1054
1055 class FillRectWithGradient : public DrawingItem {
1056 public:
1057     static Ref<FillRectWithGradient> create(const FloatRect& rect, Gradient& gradient)
1058     {
1059         return adoptRef(*new FillRectWithGradient(rect, gradient));
1060     }
1061
1062     FloatRect rect() const { return m_rect; }
1063
1064 private:
1065     FillRectWithGradient(const FloatRect& rect, Gradient& gradient)
1066         : DrawingItem(ItemType::FillRectWithGradient)
1067         , m_rect(rect)
1068         , m_gradient(gradient)
1069     {
1070     }
1071
1072     virtual void apply(GraphicsContext&) const override;
1073     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1074
1075     FloatRect m_rect;
1076     mutable Ref<Gradient> m_gradient; // FIXME: Make this not mutable
1077 };
1078
1079 class FillCompositedRect : public DrawingItem {
1080 public:
1081     static Ref<FillCompositedRect> create(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
1082     {
1083         return adoptRef(*new FillCompositedRect(rect, color, op, blendMode));
1084     }
1085
1086     FloatRect rect() const { return m_rect; }
1087     Color color() const { return m_color; }
1088     CompositeOperator compositeOperator() const { return m_op; }
1089     BlendMode blendMode() const { return m_blendMode; }
1090
1091 private:
1092     FillCompositedRect(const FloatRect& rect, const Color& color, CompositeOperator op, BlendMode blendMode)
1093         : DrawingItem(ItemType::FillCompositedRect)
1094         , m_rect(rect)
1095         , m_color(color)
1096         , m_op(op)
1097         , m_blendMode(blendMode)
1098     {
1099     }
1100
1101     virtual void apply(GraphicsContext&) const override;
1102     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1103
1104     FloatRect m_rect;
1105     Color m_color;
1106     CompositeOperator m_op;
1107     BlendMode m_blendMode;
1108 };
1109
1110 class FillRoundedRect : public DrawingItem {
1111 public:
1112     static Ref<FillRoundedRect> create(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
1113     {
1114         return adoptRef(*new FillRoundedRect(rect, color, blendMode));
1115     }
1116
1117     const FloatRoundedRect& roundedRect() const { return m_rect; }
1118     Color color() const { return m_color; }
1119     BlendMode blendMode() const { return m_blendMode; }
1120
1121 private:
1122     FillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
1123         : DrawingItem(ItemType::FillRoundedRect)
1124         , m_rect(rect)
1125         , m_color(color)
1126         , m_blendMode(blendMode)
1127     {
1128     }
1129
1130     virtual void apply(GraphicsContext&) const override;
1131     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect.rect(); }
1132
1133     FloatRoundedRect m_rect;
1134     Color m_color;
1135     BlendMode m_blendMode;
1136 };
1137
1138 class FillRectWithRoundedHole : public DrawingItem {
1139 public:
1140     static Ref<FillRectWithRoundedHole> create(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
1141     {
1142         return adoptRef(*new FillRectWithRoundedHole(rect, roundedHoleRect, color));
1143     }
1144
1145     const FloatRect& rect() const { return m_rect; }
1146     const FloatRoundedRect& roundedHoleRect() const { return m_roundedHoleRect; }
1147     Color color() const { return m_color; }
1148
1149 private:
1150     FillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color& color)
1151         : DrawingItem(ItemType::FillRectWithRoundedHole)
1152         , m_rect(rect)
1153         , m_roundedHoleRect(roundedHoleRect)
1154         , m_color(color)
1155     {
1156     }
1157
1158     virtual void apply(GraphicsContext&) const override;
1159     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1160
1161     FloatRect m_rect;
1162     FloatRoundedRect m_roundedHoleRect;
1163     Color m_color;
1164 };
1165
1166 class FillPath : public DrawingItem {
1167 public:
1168     static Ref<FillPath> create(const Path& path)
1169     {
1170         return adoptRef(*new FillPath(path));
1171     }
1172
1173     const Path& path() const { return m_path; }
1174
1175 private:
1176     FillPath(const Path& path)
1177         : DrawingItem(ItemType::FillPath)
1178         , m_path(path)
1179     {
1180     }
1181
1182     virtual void apply(GraphicsContext&) const override;
1183     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_path.fastBoundingRect(); }
1184
1185     const Path m_path;
1186 };
1187
1188 class FillEllipse : public DrawingItem {
1189 public:
1190     static Ref<FillEllipse> create(const FloatRect& rect)
1191     {
1192         return adoptRef(*new FillEllipse(rect));
1193     }
1194
1195     FloatRect rect() const { return m_rect; }
1196
1197 private:
1198     FillEllipse(const FloatRect& rect)
1199         : DrawingItem(ItemType::FillEllipse)
1200         , m_rect(rect)
1201     {
1202     }
1203
1204     virtual void apply(GraphicsContext&) const override;
1205
1206     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1207
1208     FloatRect m_rect;
1209 };
1210
1211 class StrokeRect : public DrawingItem {
1212 public:
1213     static Ref<StrokeRect> create(const FloatRect& rect, float lineWidth)
1214     {
1215         return adoptRef(*new StrokeRect(rect, lineWidth));
1216     }
1217
1218     FloatRect rect() const { return m_rect; }
1219     float lineWidth() const { return m_lineWidth; }
1220
1221 private:
1222     StrokeRect(const FloatRect& rect, float lineWidth)
1223         : DrawingItem(ItemType::StrokeRect)
1224         , m_rect(rect)
1225         , m_lineWidth(lineWidth)
1226     {
1227     }
1228
1229     virtual void apply(GraphicsContext&) const override;
1230     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1231
1232     FloatRect m_rect;
1233     float m_lineWidth;
1234 };
1235
1236 class StrokePath : public DrawingItem {
1237 public:
1238     static Ref<StrokePath> create(const Path& path)
1239     {
1240         return adoptRef(*new StrokePath(path));
1241     }
1242
1243     const Path& path() const { return m_path; }
1244
1245 private:
1246     StrokePath(const Path& path)
1247         : DrawingItem(ItemType::StrokePath)
1248         , m_path(path)
1249     {
1250     }
1251
1252     virtual void apply(GraphicsContext&) const override;
1253     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1254
1255     const Path m_path;
1256     FloatPoint m_blockLocation;
1257 };
1258
1259 class StrokeEllipse : public DrawingItem {
1260 public:
1261     static Ref<StrokeEllipse> create(const FloatRect& rect)
1262     {
1263         return adoptRef(*new StrokeEllipse(rect));
1264     }
1265
1266     FloatRect rect() const { return m_rect; }
1267
1268 private:
1269     StrokeEllipse(const FloatRect& rect)
1270         : DrawingItem(ItemType::StrokeEllipse)
1271         , m_rect(rect)
1272     {
1273     }
1274
1275     virtual void apply(GraphicsContext&) const override;
1276     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override;
1277
1278     FloatRect m_rect;
1279 };
1280
1281 class ClearRect : public DrawingItem {
1282 public:
1283     static Ref<ClearRect> create(const FloatRect& rect)
1284     {
1285         return adoptRef(*new ClearRect(rect));
1286     }
1287
1288     FloatRect rect() const { return m_rect; }
1289
1290 private:
1291     ClearRect(const FloatRect& rect)
1292         : DrawingItem(ItemType::ClearRect)
1293         , m_rect(rect)
1294     {
1295     }
1296
1297     virtual void apply(GraphicsContext&) const override;
1298     virtual Optional<FloatRect> localBounds(const GraphicsContext&) const override { return m_rect; }
1299
1300     FloatRect m_rect;
1301 };
1302
1303 #if USE(CG)
1304 class ApplyStrokePattern : public Item {
1305 public:
1306     static Ref<ApplyStrokePattern> create()
1307     {
1308         return adoptRef(*new ApplyStrokePattern);
1309     }
1310
1311 private:
1312     ApplyStrokePattern()
1313         : Item(ItemType::ApplyStrokePattern)
1314     {
1315     }
1316
1317     virtual void apply(GraphicsContext&) const override;
1318 };
1319
1320 class ApplyFillPattern : public Item {
1321 public:
1322     static Ref<ApplyFillPattern> create()
1323     {
1324         return adoptRef(*new ApplyFillPattern);
1325     }
1326
1327 private:
1328     ApplyFillPattern()
1329         : Item(ItemType::ApplyFillPattern)
1330     {
1331     }
1332
1333     virtual void apply(GraphicsContext&) const override;
1334 };
1335 #endif
1336
1337 class ApplyDeviceScaleFactor : public Item {
1338 public:
1339     static Ref<ApplyDeviceScaleFactor> create(float scaleFactor)
1340     {
1341         return adoptRef(*new ApplyDeviceScaleFactor(scaleFactor));
1342     }
1343
1344     float scaleFactor() const { return m_scaleFactor; }
1345
1346 private:
1347     ApplyDeviceScaleFactor(float scaleFactor)
1348         : Item(ItemType::ApplyDeviceScaleFactor)
1349         , m_scaleFactor(scaleFactor)
1350     {
1351     }
1352
1353     virtual void apply(GraphicsContext&) const override;
1354
1355     float m_scaleFactor;
1356 };
1357
1358 // FIXME: this needs to move.
1359 void addConvexPolygonToPath(Path&, size_t numPoints, const FloatPoint*);
1360
1361 TextStream& operator<<(TextStream&, const Item&);
1362
1363 } // namespace DisplayList
1364 } // namespace WebCore
1365
1366
1367 #define SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_DRAWINGITEM(ToValueTypeName, predicate) \
1368 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DisplayList::ToValueTypeName) \
1369     static bool isType(const WebCore::DisplayList::Item& object) { return object.predicate; } \
1370 SPECIALIZE_TYPE_TRAITS_END()
1371
1372 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_DRAWINGITEM(DrawingItem, isDrawingItem())
1373
1374 #define SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ToValueTypeName) \
1375 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DisplayList::ToValueTypeName) \
1376     static bool isType(const WebCore::DisplayList::Item& item) { return item.type() == WebCore::DisplayList::ItemType::ToValueTypeName; } \
1377 SPECIALIZE_TYPE_TRAITS_END()
1378
1379 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Save)
1380 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Restore)
1381 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Translate)
1382 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Rotate)
1383 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Scale)
1384 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ConcatenateCTM)
1385 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetState)
1386 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineCap)
1387 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineDash)
1388 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetLineJoin)
1389 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(SetMiterLimit)
1390 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(Clip)
1391 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipOut)
1392 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipOutToPath)
1393 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipPath)
1394 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClipConvexPolygon)
1395 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawGlyphs)
1396 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawImage)
1397 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledImage)
1398 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawTiledScaledImage)
1399 #if USE(CG) || USE(CAIRO)
1400 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawNativeImage)
1401 #endif
1402 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPattern)
1403 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawRect)
1404 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLine)
1405 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLinesForText)
1406 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawLineForDocumentMarker)
1407 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawEllipse)
1408 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawConvexPolygon)
1409 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawPath)
1410 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawFocusRingPath)
1411 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(DrawFocusRingRects)
1412 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRect)
1413 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithColor)
1414 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithGradient)
1415 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillCompositedRect)
1416 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRoundedRect)
1417 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillRectWithRoundedHole)
1418 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillPath)
1419 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(FillEllipse)
1420 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeRect)
1421 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokePath)
1422 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(StrokeEllipse)
1423 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClearRect)
1424 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(BeginTransparencyLayer)
1425 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(EndTransparencyLayer)
1426 #if USE(CG)
1427 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyStrokePattern)
1428 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyFillPattern)
1429 #endif
1430 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ApplyDeviceScaleFactor)
1431 SPECIALIZE_TYPE_TRAITS_DISPLAYLIST_ITEM(ClearShadow)
1432
1433 #endif // DisplayListItems_h