Make a way to test display-list drawing
[WebKit-https.git] / Source / WebCore / platform / graphics / ca / GraphicsLayerCA.h
1 /*
2  * Copyright (C) 2010 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 GraphicsLayerCA_h
27 #define GraphicsLayerCA_h
28
29 #include "GraphicsLayer.h"
30 #include "PlatformCAAnimation.h"
31 #include "PlatformCALayer.h"
32 #include "PlatformCALayerClient.h"
33 #include <wtf/HashMap.h>
34 #include <wtf/HashSet.h>
35 #include <wtf/RetainPtr.h>
36 #include <wtf/text/StringHash.h>
37
38 // Enable this to add a light red wash over the visible portion of Tiled Layers, as computed
39 // by flushCompositingState().
40 // #define VISIBLE_TILE_WASH
41
42 namespace WebCore {
43
44 namespace DisplayList {
45 class DisplayList;
46 }
47
48 class FloatRoundedRect;
49 class Image;
50 class TransformState;
51
52 class GraphicsLayerCA : public GraphicsLayer, public PlatformCALayerClient {
53 public:
54
55     WEBCORE_EXPORT explicit GraphicsLayerCA(Type, GraphicsLayerClient&);
56     WEBCORE_EXPORT virtual ~GraphicsLayerCA();
57
58     WEBCORE_EXPORT virtual void initialize(Type) override;
59
60     WEBCORE_EXPORT virtual void setName(const String&) override;
61
62     WEBCORE_EXPORT virtual PlatformLayerID primaryLayerID() const override;
63
64     WEBCORE_EXPORT virtual PlatformLayer* platformLayer() const override;
65     PlatformCALayer* platformCALayer() const { return primaryLayer(); }
66
67     WEBCORE_EXPORT virtual bool setChildren(const Vector<GraphicsLayer*>&) override;
68     WEBCORE_EXPORT virtual void addChild(GraphicsLayer*) override;
69     WEBCORE_EXPORT virtual void addChildAtIndex(GraphicsLayer*, int index) override;
70     WEBCORE_EXPORT virtual void addChildAbove(GraphicsLayer*, GraphicsLayer* sibling) override;
71     WEBCORE_EXPORT virtual void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling) override;
72     WEBCORE_EXPORT virtual bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild) override;
73
74     WEBCORE_EXPORT virtual void removeFromParent() override;
75
76     WEBCORE_EXPORT virtual void setMaskLayer(GraphicsLayer*) override;
77     WEBCORE_EXPORT virtual void setReplicatedLayer(GraphicsLayer*) override;
78
79     WEBCORE_EXPORT virtual void setPosition(const FloatPoint&) override;
80     WEBCORE_EXPORT virtual void setAnchorPoint(const FloatPoint3D&) override;
81     WEBCORE_EXPORT virtual void setSize(const FloatSize&) override;
82     WEBCORE_EXPORT virtual void setBoundsOrigin(const FloatPoint&) override;
83
84     WEBCORE_EXPORT virtual void setTransform(const TransformationMatrix&) override;
85
86     WEBCORE_EXPORT virtual void setChildrenTransform(const TransformationMatrix&) override;
87
88     WEBCORE_EXPORT virtual void setPreserves3D(bool) override;
89     WEBCORE_EXPORT virtual void setMasksToBounds(bool) override;
90     WEBCORE_EXPORT virtual void setDrawsContent(bool) override;
91     WEBCORE_EXPORT virtual void setContentsVisible(bool) override;
92     WEBCORE_EXPORT virtual void setAcceleratesDrawing(bool) override;
93     WEBCORE_EXPORT virtual void setUsesDisplayListDrawing(bool) override;
94
95     WEBCORE_EXPORT virtual void setBackgroundColor(const Color&) override;
96
97     WEBCORE_EXPORT virtual void setContentsOpaque(bool) override;
98     WEBCORE_EXPORT virtual void setBackfaceVisibility(bool) override;
99
100     // return true if we started an animation
101     WEBCORE_EXPORT virtual void setOpacity(float) override;
102
103     WEBCORE_EXPORT virtual bool setFilters(const FilterOperations&) override;
104     virtual bool filtersCanBeComposited(const FilterOperations&);
105
106     WEBCORE_EXPORT virtual bool setBackdropFilters(const FilterOperations&) override;
107     WEBCORE_EXPORT virtual void setBackdropFiltersRect(const FloatRect&) override;
108
109 #if ENABLE(CSS_COMPOSITING)
110     WEBCORE_EXPORT virtual void setBlendMode(BlendMode) override;
111 #endif
112
113     WEBCORE_EXPORT virtual void setNeedsDisplay() override;
114     WEBCORE_EXPORT virtual void setNeedsDisplayInRect(const FloatRect&, ShouldClipToLayer = ClipToLayer) override;
115     WEBCORE_EXPORT virtual void setContentsNeedsDisplay() override;
116     
117     WEBCORE_EXPORT virtual void setContentsRect(const FloatRect&) override;
118     WEBCORE_EXPORT virtual void setContentsClippingRect(const FloatRoundedRect&) override;
119     WEBCORE_EXPORT virtual bool setMasksToBoundsRect(const FloatRoundedRect&) override;
120
121     WEBCORE_EXPORT virtual void setShapeLayerPath(const Path&) override;
122     WEBCORE_EXPORT virtual void setShapeLayerWindRule(WindRule) override;
123
124     WEBCORE_EXPORT virtual void suspendAnimations(double time) override;
125     WEBCORE_EXPORT virtual void resumeAnimations() override;
126
127     WEBCORE_EXPORT virtual bool addAnimation(const KeyframeValueList&, const FloatSize& boxSize, const Animation*, const String& animationName, double timeOffset) override;
128     WEBCORE_EXPORT virtual void pauseAnimation(const String& animationName, double timeOffset) override;
129     WEBCORE_EXPORT virtual void removeAnimation(const String& animationName) override;
130
131     WEBCORE_EXPORT virtual void setContentsToImage(Image*) override;
132 #if PLATFORM(IOS)
133     WEBCORE_EXPORT virtual PlatformLayer* contentsLayerForMedia() const override;
134 #endif
135     WEBCORE_EXPORT virtual void setContentsToPlatformLayer(PlatformLayer*, ContentsLayerPurpose) override;
136     WEBCORE_EXPORT virtual void setContentsToSolidColor(const Color&) override;
137
138     virtual bool usesContentsLayer() const override { return m_contentsLayerPurpose != NoContentsLayer; }
139     
140     WEBCORE_EXPORT virtual void setShowDebugBorder(bool) override;
141     WEBCORE_EXPORT virtual void setShowRepaintCounter(bool) override;
142
143     WEBCORE_EXPORT virtual void setDebugBackgroundColor(const Color&) override;
144     WEBCORE_EXPORT virtual void setDebugBorder(const Color&, float borderWidth) override;
145
146     WEBCORE_EXPORT virtual void setCustomAppearance(CustomAppearance) override;
147
148     WEBCORE_EXPORT virtual void deviceOrPageScaleFactorChanged() override;
149
150     virtual FloatSize pixelAlignmentOffset() const override { return m_pixelAlignmentOffset; }
151
152     struct CommitState {
153         int treeDepth { 0 };
154         bool ancestorHasTransformAnimation { false };
155         bool ancestorIsViewportConstrained { false };
156         bool viewportIsStable { true };
157         
158         CommitState(bool stableViewport)
159             : viewportIsStable(stableViewport)
160         {
161         }
162     };
163     void recursiveCommitChanges(const CommitState&, const TransformState&, float pageScaleFactor = 1, const FloatPoint& positionRelativeToBase = FloatPoint(), bool affectedByPageScale = false);
164
165     WEBCORE_EXPORT virtual void flushCompositingState(const FloatRect&, bool viewportIsStable) override;
166     WEBCORE_EXPORT virtual void flushCompositingStateForThisLayerOnly(bool viewportIsStable) override;
167
168     WEBCORE_EXPORT virtual bool visibleRectChangeRequiresFlush(const FloatRect& visibleRect) const override;
169
170     WEBCORE_EXPORT virtual TiledBacking* tiledBacking() const override;
171
172 protected:
173     WEBCORE_EXPORT virtual void setOpacityInternal(float) override;
174     
175     WEBCORE_EXPORT bool animationCanBeAccelerated(const KeyframeValueList&, const Animation*) const;
176
177 private:
178     virtual bool isGraphicsLayerCA() const override { return true; }
179
180     WEBCORE_EXPORT virtual void willBeDestroyed() override;
181
182     // PlatformCALayerClient overrides
183     virtual void platformCALayerLayoutSublayersOfLayer(PlatformCALayer*) override { }
184     virtual bool platformCALayerRespondsToLayoutChanges() const override { return false; }
185     WEBCORE_EXPORT void platformCALayerCustomSublayersChanged(PlatformCALayer*) override;
186
187     WEBCORE_EXPORT void platformCALayerAnimationStarted(const String& animationKey, CFTimeInterval beginTime) override;
188     WEBCORE_EXPORT void platformCALayerAnimationEnded(const String& animationKey) override;
189     virtual CompositingCoordinatesOrientation platformCALayerContentsOrientation() const override { return contentsOrientation(); }
190     WEBCORE_EXPORT virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect& clip) override;
191     virtual bool platformCALayerShowDebugBorders() const override { return isShowingDebugBorder(); }
192     WEBCORE_EXPORT virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const override;
193     virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) override { return incrementRepaintCount(); }
194
195     virtual bool platformCALayerContentsOpaque() const override { return contentsOpaque(); }
196     virtual bool platformCALayerDrawsContent() const override { return drawsContent(); }
197     virtual void platformCALayerLayerDidDisplay(PlatformCALayer* layer) override { return layerDidDisplay(layer); }
198     WEBCORE_EXPORT virtual void platformCALayerSetNeedsToRevalidateTiles() override;
199     WEBCORE_EXPORT virtual float platformCALayerDeviceScaleFactor() const override;
200     WEBCORE_EXPORT virtual float platformCALayerContentsScaleMultiplierForNewTiles(PlatformCALayer*) const override;
201     WEBCORE_EXPORT virtual bool platformCALayerShouldAggressivelyRetainTiles(PlatformCALayer*) const override;
202     WEBCORE_EXPORT virtual bool platformCALayerShouldTemporarilyRetainTileCohorts(PlatformCALayer*) const override;
203     WEBCORE_EXPORT virtual IntSize platformCALayerTileSize() const override;
204
205     virtual bool isCommittingChanges() const override { return m_isCommittingChanges; }
206     virtual bool isUsingDisplayListDrawing(PlatformCALayer*) const override { return m_usesDisplayListDrawing; }
207
208     WEBCORE_EXPORT virtual void setIsViewportConstrained(bool) override;
209     virtual bool isViewportConstrained() const override { return m_isViewportConstrained; }
210
211     WEBCORE_EXPORT virtual String displayListAsText(DisplayList::AsTextFlags) const override;
212
213     WEBCORE_EXPORT virtual double backingStoreMemoryEstimate() const override;
214
215     WEBCORE_EXPORT virtual bool shouldRepaintOnSizeChange() const override;
216
217     WEBCORE_EXPORT void layerDidDisplay(PlatformCALayer*);
218
219     virtual PassRefPtr<PlatformCALayer> createPlatformCALayer(PlatformCALayer::LayerType, PlatformCALayerClient* owner);
220     virtual PassRefPtr<PlatformCALayer> createPlatformCALayer(PlatformLayer*, PlatformCALayerClient* owner);
221     virtual PassRefPtr<PlatformCAAnimation> createPlatformCAAnimation(PlatformCAAnimation::AnimationType, const String& keyPath);
222
223     PlatformCALayer* primaryLayer() const { return m_structuralLayer.get() ? m_structuralLayer.get() : m_layer.get(); }
224     PlatformCALayer* hostLayerForSublayers() const;
225     PlatformCALayer* layerForSuperlayer() const;
226     PlatformCALayer* animatedLayer(AnimatedPropertyID) const;
227
228     typedef String CloneID; // Identifier for a given clone, based on original/replica branching down the tree.
229     static bool isReplicatedRootClone(const CloneID& cloneID) { return cloneID[0U] & 1; }
230
231     typedef HashMap<CloneID, RefPtr<PlatformCALayer>> LayerMap;
232     LayerMap* primaryLayerClones() const { return m_structuralLayer.get() ? m_structuralLayerClones.get() : m_layerClones.get(); }
233     LayerMap* animatedLayerClones(AnimatedPropertyID) const;
234
235     bool createAnimationFromKeyframes(const KeyframeValueList&, const Animation*, const String& animationName, double timeOffset);
236     bool createTransformAnimationsFromKeyframes(const KeyframeValueList&, const Animation*, const String& animationName, double timeOffset, const FloatSize& boxSize);
237     bool createFilterAnimationsFromKeyframes(const KeyframeValueList&, const Animation*, const String& animationName, double timeOffset);
238
239     // Return autoreleased animation (use RetainPtr?)
240     PassRefPtr<PlatformCAAnimation> createBasicAnimation(const Animation*, const String& keyPath, bool additive);
241     PassRefPtr<PlatformCAAnimation> createKeyframeAnimation(const Animation*, const String&, bool additive);
242     void setupAnimation(PlatformCAAnimation*, const Animation*, bool additive);
243     
244     const TimingFunction* timingFunctionForAnimationValue(const AnimationValue&, const Animation&);
245     
246     bool setAnimationEndpoints(const KeyframeValueList&, const Animation*, PlatformCAAnimation*);
247     bool setAnimationKeyframes(const KeyframeValueList&, const Animation*, PlatformCAAnimation*);
248
249     bool setTransformAnimationEndpoints(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, TransformOperation::OperationType, bool isMatrixAnimation, const FloatSize& boxSize);
250     bool setTransformAnimationKeyframes(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, TransformOperation::OperationType, bool isMatrixAnimation, const FloatSize& boxSize);
251     
252     bool setFilterAnimationEndpoints(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, int internalFilterPropertyIndex);
253     bool setFilterAnimationKeyframes(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, int internalFilterPropertyIndex, FilterOperation::OperationType);
254
255     bool isRunningTransformAnimation() const;
256
257     bool animationIsRunning(const String& animationName) const
258     {
259         return m_runningAnimations.find(animationName) != m_runningAnimations.end();
260     }
261
262     void commitLayerChangesBeforeSublayers(CommitState&, float pageScaleFactor, const FloatPoint& positionRelativeToBase);
263     void commitLayerChangesAfterSublayers(CommitState&);
264
265     FloatPoint computePositionRelativeToBase(float& pageScale) const;
266
267     bool requiresTiledLayer(float pageScaleFactor) const;
268     void changeLayerTypeTo(PlatformCALayer::LayerType);
269
270     CompositingCoordinatesOrientation defaultContentsOrientation() const;
271
272     void setupContentsLayer(PlatformCALayer*);
273     PlatformCALayer* contentsLayer() const { return m_contentsLayer.get(); }
274
275     void updateClippingStrategy(PlatformCALayer&, RefPtr<PlatformCALayer>& shapeMaskLayer, const FloatRoundedRect&);
276
277     WEBCORE_EXPORT virtual void setReplicatedByLayer(GraphicsLayer*) override;
278
279     WEBCORE_EXPORT virtual bool canThrottleLayerFlush() const override;
280
281     WEBCORE_EXPORT virtual void getDebugBorderInfo(Color&, float& width) const override;
282     WEBCORE_EXPORT virtual void dumpAdditionalProperties(TextStream&, int indent, LayerTreeAsTextBehavior) const override;
283
284     void computePixelAlignment(float contentsScale, const FloatPoint& positionRelativeToBase,
285         FloatPoint& position, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset) const;
286
287     TransformationMatrix layerTransform(const FloatPoint& position, const TransformationMatrix* customTransform = 0) const;
288
289     enum ComputeVisibleRectFlag { RespectAnimatingTransforms = 1 << 0 };
290     typedef unsigned ComputeVisibleRectFlags;
291     
292     struct VisibleAndCoverageRects {
293         FloatRect visibleRect;
294         FloatRect coverageRect;
295         
296         VisibleAndCoverageRects(const FloatRect& visRect, const FloatRect& covRect)
297             : visibleRect(visRect)
298             , coverageRect(covRect)
299         {
300         }
301     };
302     
303     VisibleAndCoverageRects computeVisibleAndCoverageRect(TransformState&, bool accumulateTransform, ComputeVisibleRectFlags = RespectAnimatingTransforms) const;
304     bool adjustCoverageRect(VisibleAndCoverageRects&, const FloatRect& oldVisibleRect) const;
305
306     const FloatRect& visibleRect() const { return m_visibleRect; }
307     const FloatRect& coverageRect() const { return m_coverageRect; }
308
309     void setVisibleAndCoverageRects(const VisibleAndCoverageRects&, bool isViewportConstrained, bool viewportIsStable);
310     
311     static FloatRect adjustTiledLayerVisibleRect(TiledBacking*, const FloatRect& oldVisibleRect, const FloatRect& newVisibleRect, const FloatSize& oldSize, const FloatSize& newSize);
312
313     bool recursiveVisibleRectChangeRequiresFlush(const TransformState&) const;
314     
315     bool isPageTiledBackingLayer() const { return type() == Type::PageTiledBacking; }
316
317     // Used to track the path down the tree for replica layers.
318     struct ReplicaState {
319         static const size_t maxReplicaDepth = 16;
320         enum ReplicaBranchType { ChildBranch = 0, ReplicaBranch = 1 };
321         ReplicaState(ReplicaBranchType firstBranch)
322             : m_replicaDepth(0)
323         {
324             push(firstBranch);
325         }
326         
327         // Called as we walk down the tree to build replicas.
328         void push(ReplicaBranchType branchType)
329         {
330             m_replicaBranches.append(branchType);
331             if (branchType == ReplicaBranch)
332                 ++m_replicaDepth;
333         }
334         
335         void setBranchType(ReplicaBranchType branchType)
336         {
337             ASSERT(!m_replicaBranches.isEmpty());
338
339             if (m_replicaBranches.last() != branchType) {
340                 if (branchType == ReplicaBranch)
341                     ++m_replicaDepth;
342                 else
343                     --m_replicaDepth;
344             }
345
346             m_replicaBranches.last() = branchType;
347         }
348
349         void pop()
350         {
351             if (m_replicaBranches.last() == ReplicaBranch)
352                 --m_replicaDepth;
353             m_replicaBranches.removeLast();
354         }
355         
356         size_t depth() const { return m_replicaBranches.size(); }
357         size_t replicaDepth() const { return m_replicaDepth; }
358
359         CloneID cloneID() const;        
360
361     private:
362         Vector<ReplicaBranchType> m_replicaBranches;
363         size_t m_replicaDepth;
364     };
365     PassRefPtr<PlatformCALayer>replicatedLayerRoot(ReplicaState&);
366
367     enum CloneLevel { RootCloneLevel, IntermediateCloneLevel };
368     PassRefPtr<PlatformCALayer> fetchCloneLayers(GraphicsLayer* replicaRoot, ReplicaState&, CloneLevel);
369     
370     PassRefPtr<PlatformCALayer> cloneLayer(PlatformCALayer *, CloneLevel);
371     PassRefPtr<PlatformCALayer> findOrMakeClone(CloneID, PlatformCALayer *, LayerMap*, CloneLevel);
372
373     void ensureCloneLayers(CloneID, RefPtr<PlatformCALayer>& primaryLayer, RefPtr<PlatformCALayer>& structuralLayer,
374         RefPtr<PlatformCALayer>& contentsLayer, RefPtr<PlatformCALayer>& contentsClippingLayer, RefPtr<PlatformCALayer>& contentsShapeMaskLayer, RefPtr<PlatformCALayer>& shapeMaskLayer, CloneLevel);
375
376     static void clearClones(std::unique_ptr<LayerMap>&);
377
378     bool hasCloneLayers() const { return !!m_layerClones; }
379     void removeCloneLayers();
380     FloatPoint positionForCloneRootLayer() const;
381
382     // All these "update" methods will be called inside a BEGIN_BLOCK_OBJC_EXCEPTIONS/END_BLOCK_OBJC_EXCEPTIONS block.
383     void updateNames();
384     void updateSublayerList(bool maxLayerDepthReached = false);
385     void updateGeometry(float pixelAlignmentScale, const FloatPoint& positionRelativeToBase);
386     void updateTransform();
387     void updateChildrenTransform();
388     void updateMasksToBounds();
389     void updateContentsVisibility();
390     void updateContentsOpaque(float pageScaleFactor);
391     void updateBackfaceVisibility();
392     void updateStructuralLayer();
393     void updateDrawsContent();
394     void updateCoverage();
395     void updateBackgroundColor();
396
397     void updateContentsImage();
398     void updateContentsPlatformLayer();
399     void updateContentsColorLayer();
400     void updateContentsRects();
401     void updateMasksToBoundsRect();
402     void updateMaskLayer();
403     void updateReplicatedLayers();
404
405     void updateAnimations();
406     void updateContentsNeedsDisplay();
407     void updateAcceleratesDrawing();
408     void updateDebugBorder();
409     void updateTiles();
410     void updateContentsScale(float pageScaleFactor);
411     void updateCustomAppearance();
412
413     void updateOpacityOnLayer();
414     void updateFilters();
415     void updateBackdropFilters();
416     void updateBackdropFiltersRect();
417
418 #if ENABLE(CSS_COMPOSITING)
419     void updateBlendMode();
420 #endif
421
422     void updateShape();
423     void updateWindRule();
424
425     enum StructuralLayerPurpose {
426         NoStructuralLayer = 0,
427         StructuralLayerForPreserves3D,
428         StructuralLayerForReplicaFlattening,
429         StructuralLayerForBackdrop
430     };
431     void ensureStructuralLayer(StructuralLayerPurpose);
432     StructuralLayerPurpose structuralLayerPurpose() const;
433
434     void setAnimationOnLayer(PlatformCAAnimation&, AnimatedPropertyID, const String& animationName, int index, int subIndex, double timeOffset);
435     bool removeCAAnimationFromLayer(AnimatedPropertyID, const String& animationName, int index, int subINdex);
436     void pauseCAAnimationOnLayer(AnimatedPropertyID, const String& animationName, int index, int subIndex, double timeOffset);
437
438     enum MoveOrCopy { Move, Copy };
439     static void moveOrCopyLayerAnimation(MoveOrCopy, const String& animationIdentifier, PlatformCALayer *fromLayer, PlatformCALayer *toLayer);
440     void moveOrCopyAnimations(MoveOrCopy, PlatformCALayer* fromLayer, PlatformCALayer* toLayer);
441
442     void moveAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
443     {
444         moveOrCopyAnimations(Move, fromLayer, toLayer);
445     }
446     void copyAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
447     {
448         moveOrCopyAnimations(Copy, fromLayer, toLayer);
449     }
450
451     bool appendToUncommittedAnimations(const KeyframeValueList&, const TransformOperations*, const Animation*, const String& animationName, const FloatSize& boxSize, int animationIndex, double timeOffset, bool isMatrixAnimation);
452     bool appendToUncommittedAnimations(const KeyframeValueList&, const FilterOperation*, const Animation*, const String& animationName, int animationIndex, double timeOffset);
453
454     enum LayerChange : uint64_t {
455         NoChange =                      0,
456         NameChanged =                   1LLU << 1,
457         ChildrenChanged =               1LLU << 2, // also used for content layer, and preserves-3d, and size if tiling changes?
458         GeometryChanged =               1LLU << 3,
459         TransformChanged =              1LLU << 4,
460         ChildrenTransformChanged =      1LLU << 5,
461         Preserves3DChanged =            1LLU << 6,
462         MasksToBoundsChanged =          1LLU << 7,
463         DrawsContentChanged =           1LLU << 8,
464         BackgroundColorChanged =        1LLU << 9,
465         ContentsOpaqueChanged =         1LLU << 10,
466         BackfaceVisibilityChanged =     1LLU << 11,
467         OpacityChanged =                1LLU << 12,
468         AnimationChanged =              1LLU << 13,
469         DirtyRectsChanged =             1LLU << 14,
470         ContentsImageChanged =          1LLU << 15,
471         ContentsPlatformLayerChanged =  1LLU << 16,
472         ContentsColorLayerChanged =     1LLU << 17,
473         ContentsRectsChanged =          1LLU << 18,
474         MasksToBoundsRectChanged =      1LLU << 19,
475         MaskLayerChanged =              1LLU << 20,
476         ReplicatedLayerChanged =        1LLU << 21,
477         ContentsNeedsDisplay =          1LLU << 22,
478         AcceleratesDrawingChanged =     1LLU << 23,
479         ContentsScaleChanged =          1LLU << 24,
480         ContentsVisibilityChanged =     1LLU << 25,
481         CoverageRectChanged =           1LLU << 26,
482         FiltersChanged =                1LLU << 27,
483         BackdropFiltersChanged =        1LLU << 28,
484         BackdropFiltersRectChanged =    1LLU << 29,
485         TilingAreaChanged =             1LLU << 30,
486         TilesAdded =                    1LLU << 31,
487         DebugIndicatorsChanged =        1LLU << 32,
488         CustomAppearanceChanged =       1LLU << 33,
489         BlendModeChanged =              1LLU << 34,
490         ShapeChanged =                  1LLU << 35,
491         WindRuleChanged =               1LLU << 36,
492     };
493     typedef uint64_t LayerChangeFlags;
494     enum ScheduleFlushOrNot { ScheduleFlush, DontScheduleFlush };
495     void noteLayerPropertyChanged(LayerChangeFlags, ScheduleFlushOrNot = ScheduleFlush);
496     void noteSublayersChanged(ScheduleFlushOrNot = ScheduleFlush);
497     void noteChangesForScaleSensitiveProperties();
498
499     void propagateLayerChangeToReplicas(ScheduleFlushOrNot = ScheduleFlush);
500
501     void repaintLayerDirtyRects();
502
503     RefPtr<PlatformCALayer> m_layer; // The main layer
504     RefPtr<PlatformCALayer> m_structuralLayer; // A layer used for structural reasons, like preserves-3d or replica-flattening. Is the parent of m_layer.
505     RefPtr<PlatformCALayer> m_contentsClippingLayer; // A layer used to clip inner content
506     RefPtr<PlatformCALayer> m_shapeMaskLayer; // Used to clip with non-trivial corner radii.
507     RefPtr<PlatformCALayer> m_contentsLayer; // A layer used for inner content, like image and video
508     RefPtr<PlatformCALayer> m_contentsShapeMaskLayer; // Used to clip the content layer with non-trivial corner radii.
509     RefPtr<PlatformCALayer> m_backdropLayer; // The layer used for backdrop rendering, if necessary.
510
511     // References to clones of our layers, for replicated layers.
512     std::unique_ptr<LayerMap> m_layerClones;
513     std::unique_ptr<LayerMap> m_structuralLayerClones;
514     std::unique_ptr<LayerMap> m_contentsLayerClones;
515     std::unique_ptr<LayerMap> m_contentsClippingLayerClones;
516     std::unique_ptr<LayerMap> m_contentsShapeMaskLayerClones;
517     std::unique_ptr<LayerMap> m_shapeMaskLayerClones;
518
519 #ifdef VISIBLE_TILE_WASH
520     RefPtr<PlatformCALayer> m_visibleTileWashLayer;
521 #endif
522     FloatRect m_visibleRect;
523     FloatSize m_sizeAtLastCoverageRectUpdate;
524
525     FloatRect m_coverageRect; // Area for which we should maintain backing store, in the coordinate space of this layer.
526     
527     ContentsLayerPurpose m_contentsLayerPurpose { NoContentsLayer };
528     bool m_needsFullRepaint : 1;
529     bool m_usingBackdropLayerType : 1;
530     bool m_isViewportConstrained : 1;
531     bool m_intersectsCoverageRect : 1;
532     bool m_hasEverPainted : 1;
533
534     Color m_contentsSolidColor;
535
536     RetainPtr<CGImageRef> m_uncorrectedContentsImage;
537     RetainPtr<CGImageRef> m_pendingContentsImage;
538     
539     // This represents the animation of a single property. There may be multiple transform animations for
540     // a single transition or keyframe animation, so index is used to distinguish these.
541     struct LayerPropertyAnimation {
542         LayerPropertyAnimation(PassRefPtr<PlatformCAAnimation> caAnimation, const String& animationName, AnimatedPropertyID property, int index, int subIndex, double timeOffset)
543             : m_animation(caAnimation)
544             , m_name(animationName)
545             , m_property(property)
546             , m_index(index)
547             , m_subIndex(subIndex)
548             , m_timeOffset(timeOffset)
549         { }
550
551         RefPtr<PlatformCAAnimation> m_animation;
552         String m_name;
553         AnimatedPropertyID m_property;
554         int m_index;
555         int m_subIndex;
556         double m_timeOffset;
557     };
558     
559     // Uncommitted transitions and animations.
560     Vector<LayerPropertyAnimation> m_uncomittedAnimations;
561     
562     enum Action { Remove, Pause };
563     struct AnimationProcessingAction {
564         AnimationProcessingAction(Action action = Remove, double timeOffset = 0)
565             : action(action)
566             , timeOffset(timeOffset)
567         {
568         }
569         Action action;
570         double timeOffset; // only used for pause
571     };
572     typedef HashMap<String, AnimationProcessingAction> AnimationsToProcessMap;
573     AnimationsToProcessMap m_animationsToProcess;
574
575     // Map of animation names to their associated lists of property animations, so we can remove/pause them.
576     typedef HashMap<String, Vector<LayerPropertyAnimation>> AnimationsMap;
577     AnimationsMap m_runningAnimations;
578
579     Vector<FloatRect> m_dirtyRects;
580     
581     std::unique_ptr<DisplayList::DisplayList> m_displayList;
582
583     FloatSize m_pixelAlignmentOffset;
584
585     LayerChangeFlags m_uncommittedChanges { 0 };
586     bool m_isCommittingChanges { false };
587 };
588
589 } // namespace WebCore
590
591 SPECIALIZE_TYPE_TRAITS_GRAPHICSLAYER(WebCore::GraphicsLayerCA, isGraphicsLayerCA())
592
593 #endif // GraphicsLayerCA_h