95a226e0de10461773d2c6daf556cdee19619871
[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 double backingStoreMemoryEstimate() const override;
212
213     WEBCORE_EXPORT virtual bool shouldRepaintOnSizeChange() const override;
214
215     WEBCORE_EXPORT void layerDidDisplay(PlatformCALayer*);
216
217     virtual PassRefPtr<PlatformCALayer> createPlatformCALayer(PlatformCALayer::LayerType, PlatformCALayerClient* owner);
218     virtual PassRefPtr<PlatformCALayer> createPlatformCALayer(PlatformLayer*, PlatformCALayerClient* owner);
219     virtual PassRefPtr<PlatformCAAnimation> createPlatformCAAnimation(PlatformCAAnimation::AnimationType, const String& keyPath);
220
221     PlatformCALayer* primaryLayer() const { return m_structuralLayer.get() ? m_structuralLayer.get() : m_layer.get(); }
222     PlatformCALayer* hostLayerForSublayers() const;
223     PlatformCALayer* layerForSuperlayer() const;
224     PlatformCALayer* animatedLayer(AnimatedPropertyID) const;
225
226     typedef String CloneID; // Identifier for a given clone, based on original/replica branching down the tree.
227     static bool isReplicatedRootClone(const CloneID& cloneID) { return cloneID[0U] & 1; }
228
229     typedef HashMap<CloneID, RefPtr<PlatformCALayer>> LayerMap;
230     LayerMap* primaryLayerClones() const { return m_structuralLayer.get() ? m_structuralLayerClones.get() : m_layerClones.get(); }
231     LayerMap* animatedLayerClones(AnimatedPropertyID) const;
232
233     bool createAnimationFromKeyframes(const KeyframeValueList&, const Animation*, const String& animationName, double timeOffset);
234     bool createTransformAnimationsFromKeyframes(const KeyframeValueList&, const Animation*, const String& animationName, double timeOffset, const FloatSize& boxSize);
235     bool createFilterAnimationsFromKeyframes(const KeyframeValueList&, const Animation*, const String& animationName, double timeOffset);
236
237     // Return autoreleased animation (use RetainPtr?)
238     PassRefPtr<PlatformCAAnimation> createBasicAnimation(const Animation*, const String& keyPath, bool additive);
239     PassRefPtr<PlatformCAAnimation> createKeyframeAnimation(const Animation*, const String&, bool additive);
240     void setupAnimation(PlatformCAAnimation*, const Animation*, bool additive);
241     
242     const TimingFunction* timingFunctionForAnimationValue(const AnimationValue&, const Animation&);
243     
244     bool setAnimationEndpoints(const KeyframeValueList&, const Animation*, PlatformCAAnimation*);
245     bool setAnimationKeyframes(const KeyframeValueList&, const Animation*, PlatformCAAnimation*);
246
247     bool setTransformAnimationEndpoints(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, TransformOperation::OperationType, bool isMatrixAnimation, const FloatSize& boxSize);
248     bool setTransformAnimationKeyframes(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, TransformOperation::OperationType, bool isMatrixAnimation, const FloatSize& boxSize);
249     
250     bool setFilterAnimationEndpoints(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, int internalFilterPropertyIndex);
251     bool setFilterAnimationKeyframes(const KeyframeValueList&, const Animation*, PlatformCAAnimation*, int functionIndex, int internalFilterPropertyIndex, FilterOperation::OperationType);
252
253     bool isRunningTransformAnimation() const;
254
255     bool animationIsRunning(const String& animationName) const
256     {
257         return m_runningAnimations.find(animationName) != m_runningAnimations.end();
258     }
259
260     void commitLayerChangesBeforeSublayers(CommitState&, float pageScaleFactor, const FloatPoint& positionRelativeToBase);
261     void commitLayerChangesAfterSublayers(CommitState&);
262
263     FloatPoint computePositionRelativeToBase(float& pageScale) const;
264
265     bool requiresTiledLayer(float pageScaleFactor) const;
266     void changeLayerTypeTo(PlatformCALayer::LayerType);
267
268     CompositingCoordinatesOrientation defaultContentsOrientation() const;
269
270     void setupContentsLayer(PlatformCALayer*);
271     PlatformCALayer* contentsLayer() const { return m_contentsLayer.get(); }
272
273     void updateClippingStrategy(PlatformCALayer&, RefPtr<PlatformCALayer>& shapeMaskLayer, const FloatRoundedRect&);
274
275     WEBCORE_EXPORT virtual void setReplicatedByLayer(GraphicsLayer*) override;
276
277     WEBCORE_EXPORT virtual bool canThrottleLayerFlush() const override;
278
279     WEBCORE_EXPORT virtual void getDebugBorderInfo(Color&, float& width) const override;
280     WEBCORE_EXPORT virtual void dumpAdditionalProperties(TextStream&, int indent, LayerTreeAsTextBehavior) const override;
281
282     void computePixelAlignment(float contentsScale, const FloatPoint& positionRelativeToBase,
283         FloatPoint& position, FloatPoint3D& anchorPoint, FloatSize& alignmentOffset) const;
284
285     TransformationMatrix layerTransform(const FloatPoint& position, const TransformationMatrix* customTransform = 0) const;
286
287     enum ComputeVisibleRectFlag { RespectAnimatingTransforms = 1 << 0 };
288     typedef unsigned ComputeVisibleRectFlags;
289     
290     struct VisibleAndCoverageRects {
291         FloatRect visibleRect;
292         FloatRect coverageRect;
293         
294         VisibleAndCoverageRects(const FloatRect& visRect, const FloatRect& covRect)
295             : visibleRect(visRect)
296             , coverageRect(covRect)
297         {
298         }
299     };
300     
301     VisibleAndCoverageRects computeVisibleAndCoverageRect(TransformState&, bool accumulateTransform, ComputeVisibleRectFlags = RespectAnimatingTransforms) const;
302     bool adjustCoverageRect(VisibleAndCoverageRects&, const FloatRect& oldVisibleRect) const;
303
304     const FloatRect& visibleRect() const { return m_visibleRect; }
305     const FloatRect& coverageRect() const { return m_coverageRect; }
306
307     void setVisibleAndCoverageRects(const VisibleAndCoverageRects&, bool isViewportConstrained, bool viewportIsStable);
308     
309     static FloatRect adjustTiledLayerVisibleRect(TiledBacking*, const FloatRect& oldVisibleRect, const FloatRect& newVisibleRect, const FloatSize& oldSize, const FloatSize& newSize);
310
311     bool recursiveVisibleRectChangeRequiresFlush(const TransformState&) const;
312     
313     bool isPageTiledBackingLayer() const { return type() == Type::PageTiledBacking; }
314
315     // Used to track the path down the tree for replica layers.
316     struct ReplicaState {
317         static const size_t maxReplicaDepth = 16;
318         enum ReplicaBranchType { ChildBranch = 0, ReplicaBranch = 1 };
319         ReplicaState(ReplicaBranchType firstBranch)
320             : m_replicaDepth(0)
321         {
322             push(firstBranch);
323         }
324         
325         // Called as we walk down the tree to build replicas.
326         void push(ReplicaBranchType branchType)
327         {
328             m_replicaBranches.append(branchType);
329             if (branchType == ReplicaBranch)
330                 ++m_replicaDepth;
331         }
332         
333         void setBranchType(ReplicaBranchType branchType)
334         {
335             ASSERT(!m_replicaBranches.isEmpty());
336
337             if (m_replicaBranches.last() != branchType) {
338                 if (branchType == ReplicaBranch)
339                     ++m_replicaDepth;
340                 else
341                     --m_replicaDepth;
342             }
343
344             m_replicaBranches.last() = branchType;
345         }
346
347         void pop()
348         {
349             if (m_replicaBranches.last() == ReplicaBranch)
350                 --m_replicaDepth;
351             m_replicaBranches.removeLast();
352         }
353         
354         size_t depth() const { return m_replicaBranches.size(); }
355         size_t replicaDepth() const { return m_replicaDepth; }
356
357         CloneID cloneID() const;        
358
359     private:
360         Vector<ReplicaBranchType> m_replicaBranches;
361         size_t m_replicaDepth;
362     };
363     PassRefPtr<PlatformCALayer>replicatedLayerRoot(ReplicaState&);
364
365     enum CloneLevel { RootCloneLevel, IntermediateCloneLevel };
366     PassRefPtr<PlatformCALayer> fetchCloneLayers(GraphicsLayer* replicaRoot, ReplicaState&, CloneLevel);
367     
368     PassRefPtr<PlatformCALayer> cloneLayer(PlatformCALayer *, CloneLevel);
369     PassRefPtr<PlatformCALayer> findOrMakeClone(CloneID, PlatformCALayer *, LayerMap*, CloneLevel);
370
371     void ensureCloneLayers(CloneID, RefPtr<PlatformCALayer>& primaryLayer, RefPtr<PlatformCALayer>& structuralLayer,
372         RefPtr<PlatformCALayer>& contentsLayer, RefPtr<PlatformCALayer>& contentsClippingLayer, RefPtr<PlatformCALayer>& contentsShapeMaskLayer, RefPtr<PlatformCALayer>& shapeMaskLayer, CloneLevel);
373
374     static void clearClones(std::unique_ptr<LayerMap>&);
375
376     bool hasCloneLayers() const { return !!m_layerClones; }
377     void removeCloneLayers();
378     FloatPoint positionForCloneRootLayer() const;
379
380     // All these "update" methods will be called inside a BEGIN_BLOCK_OBJC_EXCEPTIONS/END_BLOCK_OBJC_EXCEPTIONS block.
381     void updateNames();
382     void updateSublayerList(bool maxLayerDepthReached = false);
383     void updateGeometry(float pixelAlignmentScale, const FloatPoint& positionRelativeToBase);
384     void updateTransform();
385     void updateChildrenTransform();
386     void updateMasksToBounds();
387     void updateContentsVisibility();
388     void updateContentsOpaque(float pageScaleFactor);
389     void updateBackfaceVisibility();
390     void updateStructuralLayer();
391     void updateDrawsContent();
392     void updateCoverage();
393     void updateBackgroundColor();
394
395     void updateContentsImage();
396     void updateContentsPlatformLayer();
397     void updateContentsColorLayer();
398     void updateContentsRects();
399     void updateMasksToBoundsRect();
400     void updateMaskLayer();
401     void updateReplicatedLayers();
402
403     void updateAnimations();
404     void updateContentsNeedsDisplay();
405     void updateAcceleratesDrawing();
406     void updateDebugBorder();
407     void updateTiles();
408     void updateContentsScale(float pageScaleFactor);
409     void updateCustomAppearance();
410
411     void updateOpacityOnLayer();
412     void updateFilters();
413     void updateBackdropFilters();
414     void updateBackdropFiltersRect();
415
416 #if ENABLE(CSS_COMPOSITING)
417     void updateBlendMode();
418 #endif
419
420     void updateShape();
421     void updateWindRule();
422
423     enum StructuralLayerPurpose {
424         NoStructuralLayer = 0,
425         StructuralLayerForPreserves3D,
426         StructuralLayerForReplicaFlattening,
427         StructuralLayerForBackdrop
428     };
429     void ensureStructuralLayer(StructuralLayerPurpose);
430     StructuralLayerPurpose structuralLayerPurpose() const;
431
432     void setAnimationOnLayer(PlatformCAAnimation&, AnimatedPropertyID, const String& animationName, int index, int subIndex, double timeOffset);
433     bool removeCAAnimationFromLayer(AnimatedPropertyID, const String& animationName, int index, int subINdex);
434     void pauseCAAnimationOnLayer(AnimatedPropertyID, const String& animationName, int index, int subIndex, double timeOffset);
435
436     enum MoveOrCopy { Move, Copy };
437     static void moveOrCopyLayerAnimation(MoveOrCopy, const String& animationIdentifier, PlatformCALayer *fromLayer, PlatformCALayer *toLayer);
438     void moveOrCopyAnimations(MoveOrCopy, PlatformCALayer* fromLayer, PlatformCALayer* toLayer);
439
440     void moveAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
441     {
442         moveOrCopyAnimations(Move, fromLayer, toLayer);
443     }
444     void copyAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
445     {
446         moveOrCopyAnimations(Copy, fromLayer, toLayer);
447     }
448
449     bool appendToUncommittedAnimations(const KeyframeValueList&, const TransformOperations*, const Animation*, const String& animationName, const FloatSize& boxSize, int animationIndex, double timeOffset, bool isMatrixAnimation);
450     bool appendToUncommittedAnimations(const KeyframeValueList&, const FilterOperation*, const Animation*, const String& animationName, int animationIndex, double timeOffset);
451
452     enum LayerChange : uint64_t {
453         NoChange =                      0,
454         NameChanged =                   1LLU << 1,
455         ChildrenChanged =               1LLU << 2, // also used for content layer, and preserves-3d, and size if tiling changes?
456         GeometryChanged =               1LLU << 3,
457         TransformChanged =              1LLU << 4,
458         ChildrenTransformChanged =      1LLU << 5,
459         Preserves3DChanged =            1LLU << 6,
460         MasksToBoundsChanged =          1LLU << 7,
461         DrawsContentChanged =           1LLU << 8,
462         BackgroundColorChanged =        1LLU << 9,
463         ContentsOpaqueChanged =         1LLU << 10,
464         BackfaceVisibilityChanged =     1LLU << 11,
465         OpacityChanged =                1LLU << 12,
466         AnimationChanged =              1LLU << 13,
467         DirtyRectsChanged =             1LLU << 14,
468         ContentsImageChanged =          1LLU << 15,
469         ContentsPlatformLayerChanged =  1LLU << 16,
470         ContentsColorLayerChanged =     1LLU << 17,
471         ContentsRectsChanged =          1LLU << 18,
472         MasksToBoundsRectChanged =      1LLU << 19,
473         MaskLayerChanged =              1LLU << 20,
474         ReplicatedLayerChanged =        1LLU << 21,
475         ContentsNeedsDisplay =          1LLU << 22,
476         AcceleratesDrawingChanged =     1LLU << 23,
477         ContentsScaleChanged =          1LLU << 24,
478         ContentsVisibilityChanged =     1LLU << 25,
479         CoverageRectChanged =           1LLU << 26,
480         FiltersChanged =                1LLU << 27,
481         BackdropFiltersChanged =        1LLU << 28,
482         BackdropFiltersRectChanged =    1LLU << 29,
483         TilingAreaChanged =             1LLU << 30,
484         TilesAdded =                    1LLU << 31,
485         DebugIndicatorsChanged =        1LLU << 32,
486         CustomAppearanceChanged =       1LLU << 33,
487         BlendModeChanged =              1LLU << 34,
488         ShapeChanged =                  1LLU << 35,
489         WindRuleChanged =               1LLU << 36,
490     };
491     typedef uint64_t LayerChangeFlags;
492     enum ScheduleFlushOrNot { ScheduleFlush, DontScheduleFlush };
493     void noteLayerPropertyChanged(LayerChangeFlags, ScheduleFlushOrNot = ScheduleFlush);
494     void noteSublayersChanged(ScheduleFlushOrNot = ScheduleFlush);
495     void noteChangesForScaleSensitiveProperties();
496
497     void propagateLayerChangeToReplicas(ScheduleFlushOrNot = ScheduleFlush);
498
499     void repaintLayerDirtyRects();
500
501     RefPtr<PlatformCALayer> m_layer; // The main layer
502     RefPtr<PlatformCALayer> m_structuralLayer; // A layer used for structural reasons, like preserves-3d or replica-flattening. Is the parent of m_layer.
503     RefPtr<PlatformCALayer> m_contentsClippingLayer; // A layer used to clip inner content
504     RefPtr<PlatformCALayer> m_shapeMaskLayer; // Used to clip with non-trivial corner radii.
505     RefPtr<PlatformCALayer> m_contentsLayer; // A layer used for inner content, like image and video
506     RefPtr<PlatformCALayer> m_contentsShapeMaskLayer; // Used to clip the content layer with non-trivial corner radii.
507     RefPtr<PlatformCALayer> m_backdropLayer; // The layer used for backdrop rendering, if necessary.
508
509     // References to clones of our layers, for replicated layers.
510     std::unique_ptr<LayerMap> m_layerClones;
511     std::unique_ptr<LayerMap> m_structuralLayerClones;
512     std::unique_ptr<LayerMap> m_contentsLayerClones;
513     std::unique_ptr<LayerMap> m_contentsClippingLayerClones;
514     std::unique_ptr<LayerMap> m_contentsShapeMaskLayerClones;
515     std::unique_ptr<LayerMap> m_shapeMaskLayerClones;
516
517 #ifdef VISIBLE_TILE_WASH
518     RefPtr<PlatformCALayer> m_visibleTileWashLayer;
519 #endif
520     FloatRect m_visibleRect;
521     FloatSize m_sizeAtLastCoverageRectUpdate;
522
523     FloatRect m_coverageRect; // Area for which we should maintain backing store, in the coordinate space of this layer.
524     
525     ContentsLayerPurpose m_contentsLayerPurpose { NoContentsLayer };
526     bool m_needsFullRepaint : 1;
527     bool m_usingBackdropLayerType : 1;
528     bool m_isViewportConstrained : 1;
529     bool m_intersectsCoverageRect : 1;
530     bool m_hasEverPainted : 1;
531
532     Color m_contentsSolidColor;
533
534     RetainPtr<CGImageRef> m_uncorrectedContentsImage;
535     RetainPtr<CGImageRef> m_pendingContentsImage;
536     
537     // This represents the animation of a single property. There may be multiple transform animations for
538     // a single transition or keyframe animation, so index is used to distinguish these.
539     struct LayerPropertyAnimation {
540         LayerPropertyAnimation(PassRefPtr<PlatformCAAnimation> caAnimation, const String& animationName, AnimatedPropertyID property, int index, int subIndex, double timeOffset)
541             : m_animation(caAnimation)
542             , m_name(animationName)
543             , m_property(property)
544             , m_index(index)
545             , m_subIndex(subIndex)
546             , m_timeOffset(timeOffset)
547         { }
548
549         RefPtr<PlatformCAAnimation> m_animation;
550         String m_name;
551         AnimatedPropertyID m_property;
552         int m_index;
553         int m_subIndex;
554         double m_timeOffset;
555     };
556     
557     // Uncommitted transitions and animations.
558     Vector<LayerPropertyAnimation> m_uncomittedAnimations;
559     
560     enum Action { Remove, Pause };
561     struct AnimationProcessingAction {
562         AnimationProcessingAction(Action action = Remove, double timeOffset = 0)
563             : action(action)
564             , timeOffset(timeOffset)
565         {
566         }
567         Action action;
568         double timeOffset; // only used for pause
569     };
570     typedef HashMap<String, AnimationProcessingAction> AnimationsToProcessMap;
571     AnimationsToProcessMap m_animationsToProcess;
572
573     // Map of animation names to their associated lists of property animations, so we can remove/pause them.
574     typedef HashMap<String, Vector<LayerPropertyAnimation>> AnimationsMap;
575     AnimationsMap m_runningAnimations;
576
577     Vector<FloatRect> m_dirtyRects;
578     
579     std::unique_ptr<DisplayList::DisplayList> m_displayList;
580
581     FloatSize m_pixelAlignmentOffset;
582
583     LayerChangeFlags m_uncommittedChanges { 0 };
584     bool m_isCommittingChanges { false };
585 };
586
587 } // namespace WebCore
588
589 SPECIALIZE_TYPE_TRAITS_GRAPHICSLAYER(WebCore::GraphicsLayerCA, isGraphicsLayerCA())
590
591 #endif // GraphicsLayerCA_h