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