Rename AnimationController to CSSAnimationController
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 6 Feb 2017 19:21:45 +0000 (19:21 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 6 Feb 2017 19:21:45 +0000 (19:21 +0000)
https://bugs.webkit.org/show_bug.cgi?id=167829

Patch by Said Abou-Hallawa <sabouhallawa@apple.com> on 2017-02-06
Reviewed by Simon Fraser.

Source/WebCore:

AnimationController is a very generic name. The current function of this
class is CSS animation.

* CMakeLists.txt:
* WebCore.xcodeproj/project.pbxproj:
* css/CSSComputedStyleDeclaration.cpp:
(WebCore::computeRenderStyleForProperty):
* dom/Document.cpp:
* history/CachedFrame.cpp:
* page/Frame.cpp:
(WebCore::Frame::Frame):
* page/Frame.h:
(WebCore::Frame::animation):
* page/FrameView.cpp:
* page/Page.cpp:
* page/animation/AnimationBase.cpp:
* page/animation/CSSAnimationController.cpp: Renamed from Source/WebCore/page/animation/AnimationController.cpp.
(WebCore::AnimationPrivateUpdateBlock::AnimationPrivateUpdateBlock):
(WebCore::AnimationPrivateUpdateBlock::~AnimationPrivateUpdateBlock):
(WebCore::CSSAnimationControllerPrivate::CSSAnimationControllerPrivate):
(WebCore::CSSAnimationControllerPrivate::~CSSAnimationControllerPrivate):
(WebCore::CSSAnimationControllerPrivate::ensureCompositeAnimation):
(WebCore::CSSAnimationControllerPrivate::clear):
(WebCore::CSSAnimationControllerPrivate::updateAnimations):
(WebCore::CSSAnimationControllerPrivate::updateAnimationTimerForRenderer):
(WebCore::CSSAnimationControllerPrivate::updateAnimationTimer):
(WebCore::CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired):
(WebCore::CSSAnimationControllerPrivate::fireEventsAndUpdateStyle):
(WebCore::CSSAnimationControllerPrivate::startUpdateStyleIfNeededDispatcher):
(WebCore::CSSAnimationControllerPrivate::addEventToDispatch):
(WebCore::CSSAnimationControllerPrivate::addElementChangeToDispatch):
(WebCore::CSSAnimationControllerPrivate::animationFrameCallbackFired):
(WebCore::CSSAnimationControllerPrivate::animationTimerFired):
(WebCore::CSSAnimationControllerPrivate::isRunningAnimationOnRenderer):
(WebCore::CSSAnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer):
(WebCore::CSSAnimationControllerPrivate::suspendAnimations):
(WebCore::CSSAnimationControllerPrivate::resumeAnimations):
(WebCore::CSSAnimationControllerPrivate::animationsAreSuspendedForDocument):
(WebCore::CSSAnimationControllerPrivate::detachFromDocument):
(WebCore::CSSAnimationControllerPrivate::suspendAnimationsForDocument):
(WebCore::CSSAnimationControllerPrivate::resumeAnimationsForDocument):
(WebCore::CSSAnimationControllerPrivate::startAnimationsIfNotSuspended):
(WebCore::CSSAnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended):
(WebCore::CSSAnimationControllerPrivate::pauseAnimationAtTime):
(WebCore::CSSAnimationControllerPrivate::pauseTransitionAtTime):
(WebCore::CSSAnimationControllerPrivate::beginAnimationUpdateTime):
(WebCore::CSSAnimationControllerPrivate::beginAnimationUpdate):
(WebCore::CSSAnimationControllerPrivate::endAnimationUpdate):
(WebCore::CSSAnimationControllerPrivate::receivedStartTimeResponse):
(WebCore::CSSAnimationControllerPrivate::getAnimatedStyleForRenderer):
(WebCore::CSSAnimationControllerPrivate::computeExtentOfAnimation):
(WebCore::CSSAnimationControllerPrivate::numberOfActiveAnimations):
(WebCore::CSSAnimationControllerPrivate::addToAnimationsWaitingForStyle):
(WebCore::CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStyle):
(WebCore::CSSAnimationControllerPrivate::styleAvailable):
(WebCore::CSSAnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse):
(WebCore::CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse):
(WebCore::CSSAnimationControllerPrivate::startTimeResponse):
(WebCore::CSSAnimationControllerPrivate::animationWillBeRemoved):
(WebCore::CSSAnimationControllerPrivate::addToAnimationsDependentOnScroll):
(WebCore::CSSAnimationControllerPrivate::removeFromAnimationsDependentOnScroll):
(WebCore::CSSAnimationControllerPrivate::scrollWasUpdated):
(WebCore::CSSAnimationController::CSSAnimationController):
(WebCore::CSSAnimationController::~CSSAnimationController):
(WebCore::CSSAnimationController::cancelAnimations):
(WebCore::CSSAnimationController::updateAnimations):
(WebCore::CSSAnimationController::getAnimatedStyleForRenderer):
(WebCore::CSSAnimationController::computeExtentOfAnimation):
(WebCore::CSSAnimationController::notifyAnimationStarted):
(WebCore::CSSAnimationController::pauseAnimationAtTime):
(WebCore::CSSAnimationController::numberOfActiveAnimations):
(WebCore::CSSAnimationController::pauseTransitionAtTime):
(WebCore::CSSAnimationController::isRunningAnimationOnRenderer):
(WebCore::CSSAnimationController::isRunningAcceleratedAnimationOnRenderer):
(WebCore::CSSAnimationController::isSuspended):
(WebCore::CSSAnimationController::suspendAnimations):
(WebCore::CSSAnimationController::resumeAnimations):
(WebCore::CSSAnimationController::allowsNewAnimationsWhileSuspended):
(WebCore::CSSAnimationController::setAllowsNewAnimationsWhileSuspended):
(WebCore::CSSAnimationController::serviceAnimations):
(WebCore::CSSAnimationController::animationsAreSuspendedForDocument):
(WebCore::CSSAnimationController::detachFromDocument):
(WebCore::CSSAnimationController::suspendAnimationsForDocument):
(WebCore::CSSAnimationController::resumeAnimationsForDocument):
(WebCore::CSSAnimationController::startAnimationsIfNotSuspended):
(WebCore::CSSAnimationController::beginAnimationUpdate):
(WebCore::CSSAnimationController::endAnimationUpdate):
(WebCore::CSSAnimationController::supportsAcceleratedAnimationOfProperty):
(WebCore::CSSAnimationController::wantsScrollUpdates):
(WebCore::CSSAnimationController::scrollWasUpdated):
(WebCore::CSSAnimationController::hasAnimations):
* page/animation/CSSAnimationController.h: Renamed from Source/WebCore/page/animation/AnimationController.h.
(WebCore::AnimationUpdateBlock::AnimationUpdateBlock):
(WebCore::AnimationUpdateBlock::~AnimationUpdateBlock):
* page/animation/CSSAnimationControllerPrivate.h: Renamed from Source/WebCore/page/animation/AnimationControllerPrivate.h.
(WebCore::CSSAnimationControllerPrivate::hasAnimations):
(WebCore::CSSAnimationControllerPrivate::isSuspended):
(WebCore::CSSAnimationControllerPrivate::setBeginAnimationUpdateTime):
(WebCore::CSSAnimationControllerPrivate::allowsNewAnimationsWhileSuspended):
(WebCore::CSSAnimationControllerPrivate::wantsScrollUpdates):
(WebCore::CSSAnimationControllerPrivate::scrollPosition):
* page/animation/CSSPropertyAnimation.cpp:
(WebCore::CSSPropertyAnimationWrapperMap::singleton):
* page/animation/CompositeAnimation.cpp:
(WebCore::CompositeAnimation::CompositeAnimation):
* page/animation/CompositeAnimation.h:
(WebCore::CompositeAnimation::create):
(WebCore::CompositeAnimation::animationController):
* page/animation/ImplicitAnimation.cpp:
* page/animation/KeyframeAnimation.cpp:
* page/ios/FrameIOS.mm:
* platform/graphics/GraphicsLayer.h:
* rendering/RenderElement.h:
* rendering/RenderLayer.cpp:
* rendering/RenderLayerBacking.cpp:
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::requiresCompositingForAnimation):
* rendering/RenderObject.cpp:
* rendering/RenderObject.h:
(WebCore::RenderObject::animation):
* testing/Internals.cpp:

Source/WebKit/mac:

* WebView/WebFrame.mm:
* WebView/WebView.mm:

Source/WebKit/win:

* WebFrame.cpp:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@211741 268f45cc-cd09-0410-ab3c-d52691b4dbfc

33 files changed:
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/css/CSSComputedStyleDeclaration.cpp
Source/WebCore/dom/Document.cpp
Source/WebCore/history/CachedFrame.cpp
Source/WebCore/page/Frame.cpp
Source/WebCore/page/Frame.h
Source/WebCore/page/FrameView.cpp
Source/WebCore/page/Page.cpp
Source/WebCore/page/animation/AnimationBase.cpp
Source/WebCore/page/animation/CSSAnimationController.cpp [moved from Source/WebCore/page/animation/AnimationController.cpp with 73% similarity]
Source/WebCore/page/animation/CSSAnimationController.h [moved from Source/WebCore/page/animation/AnimationController.h with 93% similarity]
Source/WebCore/page/animation/CSSAnimationControllerPrivate.h [moved from Source/WebCore/page/animation/AnimationControllerPrivate.h with 97% similarity]
Source/WebCore/page/animation/CSSPropertyAnimation.cpp
Source/WebCore/page/animation/CompositeAnimation.cpp
Source/WebCore/page/animation/CompositeAnimation.h
Source/WebCore/page/animation/ImplicitAnimation.cpp
Source/WebCore/page/animation/KeyframeAnimation.cpp
Source/WebCore/page/ios/FrameIOS.mm
Source/WebCore/platform/graphics/GraphicsLayer.h
Source/WebCore/rendering/RenderElement.h
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayerBacking.cpp
Source/WebCore/rendering/RenderLayerCompositor.cpp
Source/WebCore/rendering/RenderObject.cpp
Source/WebCore/rendering/RenderObject.h
Source/WebCore/testing/Internals.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/WebView/WebFrame.mm
Source/WebKit/mac/WebView/WebView.mm
Source/WebKit/win/ChangeLog
Source/WebKit/win/WebFrame.cpp

index 8a72bda..5b9a5cd 100644 (file)
@@ -2028,7 +2028,7 @@ set(WebCore_SOURCES
     page/WorkerNavigator.cpp
 
     page/animation/AnimationBase.cpp
-    page/animation/AnimationController.cpp
+    page/animation/CSSAnimationController.cpp
     page/animation/CSSPropertyAnimation.cpp
     page/animation/CompositeAnimation.cpp
     page/animation/ImplicitAnimation.cpp
index 0350c61..c706700 100644 (file)
@@ -1,3 +1,132 @@
+2017-02-06  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Rename AnimationController to CSSAnimationController
+        https://bugs.webkit.org/show_bug.cgi?id=167829
+
+        Reviewed by Simon Fraser.
+
+        AnimationController is a very generic name. The current function of this
+        class is CSS animation.
+
+        * CMakeLists.txt:
+        * WebCore.xcodeproj/project.pbxproj:
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::computeRenderStyleForProperty):
+        * dom/Document.cpp:
+        * history/CachedFrame.cpp:
+        * page/Frame.cpp:
+        (WebCore::Frame::Frame):
+        * page/Frame.h:
+        (WebCore::Frame::animation):
+        * page/FrameView.cpp:
+        * page/Page.cpp:
+        * page/animation/AnimationBase.cpp:
+        * page/animation/CSSAnimationController.cpp: Renamed from Source/WebCore/page/animation/AnimationController.cpp.
+        (WebCore::AnimationPrivateUpdateBlock::AnimationPrivateUpdateBlock):
+        (WebCore::AnimationPrivateUpdateBlock::~AnimationPrivateUpdateBlock):
+        (WebCore::CSSAnimationControllerPrivate::CSSAnimationControllerPrivate):
+        (WebCore::CSSAnimationControllerPrivate::~CSSAnimationControllerPrivate):
+        (WebCore::CSSAnimationControllerPrivate::ensureCompositeAnimation):
+        (WebCore::CSSAnimationControllerPrivate::clear):
+        (WebCore::CSSAnimationControllerPrivate::updateAnimations):
+        (WebCore::CSSAnimationControllerPrivate::updateAnimationTimerForRenderer):
+        (WebCore::CSSAnimationControllerPrivate::updateAnimationTimer):
+        (WebCore::CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired):
+        (WebCore::CSSAnimationControllerPrivate::fireEventsAndUpdateStyle):
+        (WebCore::CSSAnimationControllerPrivate::startUpdateStyleIfNeededDispatcher):
+        (WebCore::CSSAnimationControllerPrivate::addEventToDispatch):
+        (WebCore::CSSAnimationControllerPrivate::addElementChangeToDispatch):
+        (WebCore::CSSAnimationControllerPrivate::animationFrameCallbackFired):
+        (WebCore::CSSAnimationControllerPrivate::animationTimerFired):
+        (WebCore::CSSAnimationControllerPrivate::isRunningAnimationOnRenderer):
+        (WebCore::CSSAnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer):
+        (WebCore::CSSAnimationControllerPrivate::suspendAnimations):
+        (WebCore::CSSAnimationControllerPrivate::resumeAnimations):
+        (WebCore::CSSAnimationControllerPrivate::animationsAreSuspendedForDocument):
+        (WebCore::CSSAnimationControllerPrivate::detachFromDocument):
+        (WebCore::CSSAnimationControllerPrivate::suspendAnimationsForDocument):
+        (WebCore::CSSAnimationControllerPrivate::resumeAnimationsForDocument):
+        (WebCore::CSSAnimationControllerPrivate::startAnimationsIfNotSuspended):
+        (WebCore::CSSAnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended):
+        (WebCore::CSSAnimationControllerPrivate::pauseAnimationAtTime):
+        (WebCore::CSSAnimationControllerPrivate::pauseTransitionAtTime):
+        (WebCore::CSSAnimationControllerPrivate::beginAnimationUpdateTime):
+        (WebCore::CSSAnimationControllerPrivate::beginAnimationUpdate):
+        (WebCore::CSSAnimationControllerPrivate::endAnimationUpdate):
+        (WebCore::CSSAnimationControllerPrivate::receivedStartTimeResponse):
+        (WebCore::CSSAnimationControllerPrivate::getAnimatedStyleForRenderer):
+        (WebCore::CSSAnimationControllerPrivate::computeExtentOfAnimation):
+        (WebCore::CSSAnimationControllerPrivate::numberOfActiveAnimations):
+        (WebCore::CSSAnimationControllerPrivate::addToAnimationsWaitingForStyle):
+        (WebCore::CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStyle):
+        (WebCore::CSSAnimationControllerPrivate::styleAvailable):
+        (WebCore::CSSAnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse):
+        (WebCore::CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse):
+        (WebCore::CSSAnimationControllerPrivate::startTimeResponse):
+        (WebCore::CSSAnimationControllerPrivate::animationWillBeRemoved):
+        (WebCore::CSSAnimationControllerPrivate::addToAnimationsDependentOnScroll):
+        (WebCore::CSSAnimationControllerPrivate::removeFromAnimationsDependentOnScroll):
+        (WebCore::CSSAnimationControllerPrivate::scrollWasUpdated):
+        (WebCore::CSSAnimationController::CSSAnimationController):
+        (WebCore::CSSAnimationController::~CSSAnimationController):
+        (WebCore::CSSAnimationController::cancelAnimations):
+        (WebCore::CSSAnimationController::updateAnimations):
+        (WebCore::CSSAnimationController::getAnimatedStyleForRenderer):
+        (WebCore::CSSAnimationController::computeExtentOfAnimation):
+        (WebCore::CSSAnimationController::notifyAnimationStarted):
+        (WebCore::CSSAnimationController::pauseAnimationAtTime):
+        (WebCore::CSSAnimationController::numberOfActiveAnimations):
+        (WebCore::CSSAnimationController::pauseTransitionAtTime):
+        (WebCore::CSSAnimationController::isRunningAnimationOnRenderer):
+        (WebCore::CSSAnimationController::isRunningAcceleratedAnimationOnRenderer):
+        (WebCore::CSSAnimationController::isSuspended):
+        (WebCore::CSSAnimationController::suspendAnimations):
+        (WebCore::CSSAnimationController::resumeAnimations):
+        (WebCore::CSSAnimationController::allowsNewAnimationsWhileSuspended):
+        (WebCore::CSSAnimationController::setAllowsNewAnimationsWhileSuspended):
+        (WebCore::CSSAnimationController::serviceAnimations):
+        (WebCore::CSSAnimationController::animationsAreSuspendedForDocument):
+        (WebCore::CSSAnimationController::detachFromDocument):
+        (WebCore::CSSAnimationController::suspendAnimationsForDocument):
+        (WebCore::CSSAnimationController::resumeAnimationsForDocument):
+        (WebCore::CSSAnimationController::startAnimationsIfNotSuspended):
+        (WebCore::CSSAnimationController::beginAnimationUpdate):
+        (WebCore::CSSAnimationController::endAnimationUpdate):
+        (WebCore::CSSAnimationController::supportsAcceleratedAnimationOfProperty):
+        (WebCore::CSSAnimationController::wantsScrollUpdates):
+        (WebCore::CSSAnimationController::scrollWasUpdated):
+        (WebCore::CSSAnimationController::hasAnimations):
+        * page/animation/CSSAnimationController.h: Renamed from Source/WebCore/page/animation/AnimationController.h.
+        (WebCore::AnimationUpdateBlock::AnimationUpdateBlock):
+        (WebCore::AnimationUpdateBlock::~AnimationUpdateBlock):
+        * page/animation/CSSAnimationControllerPrivate.h: Renamed from Source/WebCore/page/animation/AnimationControllerPrivate.h.
+        (WebCore::CSSAnimationControllerPrivate::hasAnimations):
+        (WebCore::CSSAnimationControllerPrivate::isSuspended):
+        (WebCore::CSSAnimationControllerPrivate::setBeginAnimationUpdateTime):
+        (WebCore::CSSAnimationControllerPrivate::allowsNewAnimationsWhileSuspended):
+        (WebCore::CSSAnimationControllerPrivate::wantsScrollUpdates):
+        (WebCore::CSSAnimationControllerPrivate::scrollPosition):
+        * page/animation/CSSPropertyAnimation.cpp:
+        (WebCore::CSSPropertyAnimationWrapperMap::singleton):
+        * page/animation/CompositeAnimation.cpp:
+        (WebCore::CompositeAnimation::CompositeAnimation):
+        * page/animation/CompositeAnimation.h:
+        (WebCore::CompositeAnimation::create):
+        (WebCore::CompositeAnimation::animationController):
+        * page/animation/ImplicitAnimation.cpp:
+        * page/animation/KeyframeAnimation.cpp:
+        * page/ios/FrameIOS.mm:
+        * platform/graphics/GraphicsLayer.h:
+        * rendering/RenderElement.h:
+        * rendering/RenderLayer.cpp:
+        * rendering/RenderLayerBacking.cpp:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::requiresCompositingForAnimation):
+        * rendering/RenderObject.cpp:
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::animation):
+        * testing/Internals.cpp:
+
 2017-02-06  Zalan Bujtas  <zalan@apple.com>
 
         Simple line layout: Use simplified text measuring when possible.
index f0528be..1565f46 100644 (file)
                0F11A54F0F39233100C37884 /* RenderSelectionInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F11A54E0F39233100C37884 /* RenderSelectionInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F13163E16ED0CC80035CC04 /* PlatformCAFilters.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F13163D16ED0CC80035CC04 /* PlatformCAFilters.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F13164016ED0CDE0035CC04 /* PlatformCAFiltersCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 0F13163F16ED0CDE0035CC04 /* PlatformCAFiltersCocoa.mm */; };
-               0F15DA8A0F3AAEE70000CE47 /* AnimationControllerPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F15DA890F3AAEE70000CE47 /* AnimationControllerPrivate.h */; };
+               0F15DA8A0F3AAEE70000CE47 /* CSSAnimationControllerPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F15DA890F3AAEE70000CE47 /* CSSAnimationControllerPrivate.h */; };
                0F15ED5B1B7EC7C500EDDFEB /* WillChangeData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F15ED591B7EC7C500EDDFEB /* WillChangeData.cpp */; };
                0F15ED5C1B7EC7C500EDDFEB /* WillChangeData.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F15ED5A1B7EC7C500EDDFEB /* WillChangeData.h */; settings = {ATTRIBUTES = (Private, ); }; };
                0F1774801378B772009DA76A /* ScrollAnimatorIOS.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F17747E1378B771009DA76A /* ScrollAnimatorIOS.h */; };
                316FE0740E6CCBEE00BF6088 /* JSCSSKeyframesRule.h in Headers */ = {isa = PBXBuildFile; fileRef = 316FE0700E6CCBEE00BF6088 /* JSCSSKeyframesRule.h */; };
                316FE1110E6E1DA700BF6088 /* AnimationBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316FE1070E6E1DA700BF6088 /* AnimationBase.cpp */; };
                316FE1120E6E1DA700BF6088 /* AnimationBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 316FE1080E6E1DA700BF6088 /* AnimationBase.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               316FE1130E6E1DA700BF6088 /* AnimationController.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316FE1090E6E1DA700BF6088 /* AnimationController.cpp */; };
-               316FE1140E6E1DA700BF6088 /* AnimationController.h in Headers */ = {isa = PBXBuildFile; fileRef = 316FE10A0E6E1DA700BF6088 /* AnimationController.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               316FE1130E6E1DA700BF6088 /* CSSAnimationController.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316FE1090E6E1DA700BF6088 /* CSSAnimationController.cpp */; };
+               316FE1140E6E1DA700BF6088 /* CSSAnimationController.h in Headers */ = {isa = PBXBuildFile; fileRef = 316FE10A0E6E1DA700BF6088 /* CSSAnimationController.h */; settings = {ATTRIBUTES = (Private, ); }; };
                316FE1150E6E1DA700BF6088 /* CompositeAnimation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316FE10B0E6E1DA700BF6088 /* CompositeAnimation.cpp */; };
                316FE1160E6E1DA700BF6088 /* CompositeAnimation.h in Headers */ = {isa = PBXBuildFile; fileRef = 316FE10C0E6E1DA700BF6088 /* CompositeAnimation.h */; };
                316FE1170E6E1DA700BF6088 /* ImplicitAnimation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 316FE10D0E6E1DA700BF6088 /* ImplicitAnimation.cpp */; };
                0F11A54E0F39233100C37884 /* RenderSelectionInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderSelectionInfo.h; sourceTree = "<group>"; };
                0F13163D16ED0CC80035CC04 /* PlatformCAFilters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformCAFilters.h; sourceTree = "<group>"; };
                0F13163F16ED0CDE0035CC04 /* PlatformCAFiltersCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = PlatformCAFiltersCocoa.mm; sourceTree = "<group>"; };
-               0F15DA890F3AAEE70000CE47 /* AnimationControllerPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AnimationControllerPrivate.h; sourceTree = "<group>"; };
+               0F15DA890F3AAEE70000CE47 /* CSSAnimationControllerPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSAnimationControllerPrivate.h; sourceTree = "<group>"; };
                0F15ED591B7EC7C500EDDFEB /* WillChangeData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WillChangeData.cpp; sourceTree = "<group>"; };
                0F15ED5A1B7EC7C500EDDFEB /* WillChangeData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WillChangeData.h; sourceTree = "<group>"; };
                0F17747E1378B771009DA76A /* ScrollAnimatorIOS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollAnimatorIOS.h; sourceTree = "<group>"; };
                316FE0920E6CCD7F00BF6088 /* CSSKeyframesRule.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CSSKeyframesRule.idl; sourceTree = "<group>"; };
                316FE1070E6E1DA700BF6088 /* AnimationBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AnimationBase.cpp; sourceTree = "<group>"; };
                316FE1080E6E1DA700BF6088 /* AnimationBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AnimationBase.h; sourceTree = "<group>"; };
-               316FE1090E6E1DA700BF6088 /* AnimationController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AnimationController.cpp; sourceTree = "<group>"; };
-               316FE10A0E6E1DA700BF6088 /* AnimationController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AnimationController.h; sourceTree = "<group>"; };
+               316FE1090E6E1DA700BF6088 /* CSSAnimationController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSAnimationController.cpp; sourceTree = "<group>"; };
+               316FE10A0E6E1DA700BF6088 /* CSSAnimationController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSAnimationController.h; sourceTree = "<group>"; };
                316FE10B0E6E1DA700BF6088 /* CompositeAnimation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CompositeAnimation.cpp; sourceTree = "<group>"; };
                316FE10C0E6E1DA700BF6088 /* CompositeAnimation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CompositeAnimation.h; sourceTree = "<group>"; };
                316FE10D0E6E1DA700BF6088 /* ImplicitAnimation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImplicitAnimation.cpp; sourceTree = "<group>"; };
                        children = (
                                316FE1070E6E1DA700BF6088 /* AnimationBase.cpp */,
                                316FE1080E6E1DA700BF6088 /* AnimationBase.h */,
-                               316FE1090E6E1DA700BF6088 /* AnimationController.cpp */,
-                               316FE10A0E6E1DA700BF6088 /* AnimationController.h */,
-                               0F15DA890F3AAEE70000CE47 /* AnimationControllerPrivate.h */,
+                               316FE1090E6E1DA700BF6088 /* CSSAnimationController.cpp */,
+                               316FE10A0E6E1DA700BF6088 /* CSSAnimationController.h */,
+                               0F15DA890F3AAEE70000CE47 /* CSSAnimationControllerPrivate.h */,
                                316FE10B0E6E1DA700BF6088 /* CompositeAnimation.cpp */,
                                316FE10C0E6E1DA700BF6088 /* CompositeAnimation.h */,
                                78D02BC3154A18DF00B62D05 /* CSSPropertyAnimation.cpp */,
                                490707E71219C04300D90E51 /* ANGLEWebKitBridge.h in Headers */,
                                49E912AB0EFAC906009D0CAF /* Animation.h in Headers */,
                                316FE1120E6E1DA700BF6088 /* AnimationBase.h in Headers */,
-                               316FE1140E6E1DA700BF6088 /* AnimationController.h in Headers */,
-                               0F15DA8A0F3AAEE70000CE47 /* AnimationControllerPrivate.h in Headers */,
+                               316FE1140E6E1DA700BF6088 /* CSSAnimationController.h in Headers */,
+                               0F15DA8A0F3AAEE70000CE47 /* CSSAnimationControllerPrivate.h in Headers */,
                                319848011A1D817B00A13318 /* AnimationEvent.h in Headers */,
                                49E912AD0EFAC906009D0CAF /* AnimationList.h in Headers */,
                                31DCD29D1AB4FBDE0072E817 /* AnimationTrigger.h in Headers */,
                                490707E61219C04300D90E51 /* ANGLEWebKitBridge.cpp in Sources */,
                                49E912AA0EFAC906009D0CAF /* Animation.cpp in Sources */,
                                316FE1110E6E1DA700BF6088 /* AnimationBase.cpp in Sources */,
-                               316FE1130E6E1DA700BF6088 /* AnimationController.cpp in Sources */,
+                               316FE1130E6E1DA700BF6088 /* CSSAnimationController.cpp in Sources */,
                                120DE3F11C86CCC600B6D4DD /* AnimationEffect.cpp in Sources */,
                                319848021A1D818100A13318 /* AnimationEvent.cpp in Sources */,
                                49E912AC0EFAC906009D0CAF /* AnimationList.cpp in Sources */,
index fdd294c..e38b54f 100644 (file)
@@ -25,9 +25,9 @@
 #include "config.h"
 #include "CSSComputedStyleDeclaration.h"
 
-#include "AnimationController.h"
 #include "BasicShapeFunctions.h"
 #include "BasicShapes.h"
+#include "CSSAnimationController.h"
 #include "CSSAnimationTriggerScrollValue.h"
 #include "CSSAspectRatioValue.h"
 #include "CSSBasicShapes.h"
@@ -2408,7 +2408,7 @@ static inline const RenderStyle* computeRenderStyleForProperty(Element& element,
 {
     auto* renderer = element.renderer();
 
-    if (renderer && renderer->isComposited() && AnimationController::supportsAcceleratedAnimationOfProperty(propertyID)) {
+    if (renderer && renderer->isComposited() && CSSAnimationController::supportsAcceleratedAnimationOfProperty(propertyID)) {
         ownedStyle = renderer->animation().getAnimatedStyleForRenderer(*renderer);
         if (pseudoElementSpecifier && !element.isPseudoElement()) {
             // FIXME: This cached pseudo style will only exist if the animation has been run at least once.
index b6a0995..440ffaf 100644 (file)
@@ -29,9 +29,9 @@
 #include "Document.h"
 
 #include "AXObjectCache.h"
-#include "AnimationController.h"
 #include "Attr.h"
 #include "CDATASection.h"
+#include "CSSAnimationController.h"
 #include "CSSFontSelector.h"
 #include "CSSStyleDeclaration.h"
 #include "CSSStyleSheet.h"
index 21f24ad..0eaf6c6 100644 (file)
  */
  
 #include "config.h"
-#include "CachedPage.h"
+#include "CachedFrame.h"
 
-#include "AnimationController.h"
+#include "CSSAnimationController.h"
 #include "CachedFramePlatformData.h"
+#include "CachedPage.h"
 #include "DOMWindow.h"
 #include "Document.h"
 #include "DocumentLoader.h"
index 878ee1c..a5ae52b 100644 (file)
@@ -30,9 +30,9 @@
 #include "config.h"
 #include "Frame.h"
 
-#include "AnimationController.h"
 #include "ApplyStyleCommand.h"
 #include "BackForwardController.h"
+#include "CSSAnimationController.h"
 #include "CSSComputedStyleDeclaration.h"
 #include "CSSPropertyNames.h"
 #include "CachedCSSStyleSheet.h"
@@ -160,7 +160,7 @@ Frame::Frame(Page& page, HTMLFrameOwnerElement* ownerElement, FrameLoaderClient&
     , m_script(std::make_unique<ScriptController>(*this))
     , m_editor(std::make_unique<Editor>(*this))
     , m_selection(std::make_unique<FrameSelection>(this))
-    , m_animationController(std::make_unique<AnimationController>(*this))
+    , m_animationController(std::make_unique<CSSAnimationController>(*this))
 #if PLATFORM(IOS)
     , m_overflowAutoScrollTimer(*this, &Frame::overflowAutoScrollTimerFired)
     , m_selectionChangeCallbacksDisabled(false)
index 9a8f73c..8e5724e 100644 (file)
@@ -60,7 +60,7 @@ class RegularExpression;
 
 namespace WebCore {
 
-class AnimationController;
+class CSSAnimationController;
 class Color;
 class Document;
 class Editor;
@@ -149,7 +149,7 @@ public:
     NavigationScheduler& navigationScheduler() const;
     FrameSelection& selection() const;
     FrameTree& tree() const;
-    AnimationController& animation() const;
+    CSSAnimationController& animation() const;
     ScriptController& script();
     
     WEBCORE_EXPORT RenderView* contentRenderer() const; // Root of the render tree for the document contained in this frame.
@@ -290,7 +290,7 @@ private:
     const std::unique_ptr<ScriptController> m_script;
     const std::unique_ptr<Editor> m_editor;
     const std::unique_ptr<FrameSelection> m_selection;
-    const std::unique_ptr<AnimationController> m_animationController;
+    const std::unique_ptr<CSSAnimationController> m_animationController;
 
 #if ENABLE(DATA_DETECTION)
     RetainPtr<NSArray> m_dataDetectionResults;
@@ -366,7 +366,7 @@ inline Editor& Frame::editor() const
     return *m_editor;
 }
 
-inline AnimationController& Frame::animation() const
+inline CSSAnimationController& Frame::animation() const
 {
     return *m_animationController;
 }
index cb1ba1d..c28c721 100644 (file)
@@ -28,8 +28,8 @@
 #include "FrameView.h"
 
 #include "AXObjectCache.h"
-#include "AnimationController.h"
 #include "BackForwardController.h"
+#include "CSSAnimationController.h"
 #include "CachedImage.h"
 #include "CachedResourceLoader.h"
 #include "Chrome.h"
index 9fe6b13..b2539fb 100644 (file)
 
 #include "ActivityStateChangeObserver.h"
 #include "AlternativeTextClient.h"
-#include "AnimationController.h"
 #include "ApplicationCacheStorage.h"
 #include "BackForwardClient.h"
 #include "BackForwardController.h"
+#include "CSSAnimationController.h"
 #include "Chrome.h"
 #include "ChromeClient.h"
 #include "ClientRectList.h"
index d9a74e0..e177f0d 100644 (file)
@@ -29,7 +29,7 @@
 #include "config.h"
 #include "AnimationBase.h"
 
-#include "AnimationControllerPrivate.h"
+#include "CSSAnimationControllerPrivate.h"
 #include "CSSPrimitiveValue.h"
 #include "CSSPropertyAnimation.h"
 #include "CompositeAnimation.h"
  */
 
 #include "config.h"
-#include "AnimationController.h"
+#include "CSSAnimationController.h"
 
 #include "AnimationBase.h"
-#include "AnimationControllerPrivate.h"
 #include "AnimationEvent.h"
+#include "CSSAnimationControllerPrivate.h"
 #include "CSSPropertyAnimation.h"
 #include "CSSPropertyParser.h"
 #include "CompositeAnimation.h"
@@ -53,7 +53,7 @@ static const double cBeginAnimationUpdateTimeNotSet = -1;
 
 class AnimationPrivateUpdateBlock {
 public:
-    AnimationPrivateUpdateBlock(AnimationControllerPrivate& animationController)
+    AnimationPrivateUpdateBlock(CSSAnimationControllerPrivate& animationController)
         : m_animationController(animationController)
     {
         m_animationController.beginAnimationUpdate();
@@ -64,12 +64,12 @@ public:
         m_animationController.endAnimationUpdate();
     }
     
-    AnimationControllerPrivate& m_animationController;
+    CSSAnimationControllerPrivate& m_animationController;
 };
 
-AnimationControllerPrivate::AnimationControllerPrivate(Frame& frame)
-    : m_animationTimer(*this, &AnimationControllerPrivate::animationTimerFired)
-    , m_updateStyleIfNeededDispatcher(*this, &AnimationControllerPrivate::updateStyleIfNeededDispatcherFired)
+CSSAnimationControllerPrivate::CSSAnimationControllerPrivate(Frame& frame)
+    : m_animationTimer(*this, &CSSAnimationControllerPrivate::animationTimerFired)
+    , m_updateStyleIfNeededDispatcher(*this, &CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired)
     , m_frame(frame)
     , m_beginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet)
     , m_beginAnimationUpdateCount(0)
@@ -79,11 +79,11 @@ AnimationControllerPrivate::AnimationControllerPrivate(Frame& frame)
 {
 }
 
-AnimationControllerPrivate::~AnimationControllerPrivate()
+CSSAnimationControllerPrivate::~CSSAnimationControllerPrivate()
 {
 }
 
-CompositeAnimation& AnimationControllerPrivate::ensureCompositeAnimation(RenderElement& renderer)
+CompositeAnimation& CSSAnimationControllerPrivate::ensureCompositeAnimation(RenderElement& renderer)
 {
     auto result = m_compositeAnimations.add(&renderer, nullptr);
     if (result.isNewEntry) {
@@ -97,9 +97,9 @@ CompositeAnimation& AnimationControllerPrivate::ensureCompositeAnimation(RenderE
     return *result.iterator->value;
 }
 
-bool AnimationControllerPrivate::clear(RenderElement& renderer)
+bool CSSAnimationControllerPrivate::clear(RenderElement& renderer)
 {
-    LOG(Animations, "AnimationControllerPrivate %p clear: %p", this, &renderer);
+    LOG(Animations, "CSSAnimationControllerPrivate %p clear: %p", this, &renderer);
 
     ASSERT(renderer.isCSSAnimating());
     ASSERT(m_compositeAnimations.contains(&renderer));
@@ -123,7 +123,7 @@ bool AnimationControllerPrivate::clear(RenderElement& renderer)
     return animation->isSuspended();
 }
 
-double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
+double CSSAnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
 {
     AnimationPrivateUpdateBlock updateBlock(*this);
     double timeToNextService = -1;
@@ -153,7 +153,7 @@ double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/*
     return timeToNextService;
 }
 
-void AnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement& renderer)
+void CSSAnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement& renderer)
 {
     double timeToNextService = 0;
 
@@ -167,7 +167,7 @@ void AnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement&
     m_animationTimer.startOneShot(timeToNextService);
 }
 
-void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
+void CSSAnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/* = DoNotCallSetChanged*/)
 {
     double timeToNextService = updateAnimations(callSetChanged);
 
@@ -175,7 +175,7 @@ void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/
 
     // If we want service immediately, we start a repeating timer to reduce the overhead of starting
     if (!timeToNextService) {
-        if (!m_animationTimer.isActive() || m_animationTimer.repeatInterval() == 0)
+        if (!m_animationTimer.isActive() || !m_animationTimer.repeatInterval())
             m_animationTimer.startRepeating(cAnimationTimerDelay);
         return;
     }
@@ -191,12 +191,12 @@ void AnimationControllerPrivate::updateAnimationTimer(SetChanged callSetChanged/
     m_animationTimer.startOneShot(timeToNextService);
 }
 
-void AnimationControllerPrivate::updateStyleIfNeededDispatcherFired()
+void CSSAnimationControllerPrivate::updateStyleIfNeededDispatcherFired()
 {
     fireEventsAndUpdateStyle();
 }
 
-void AnimationControllerPrivate::fireEventsAndUpdateStyle()
+void CSSAnimationControllerPrivate::fireEventsAndUpdateStyle()
 {
     // Protect the frame from getting destroyed in the event handler
     Ref<Frame> protector(m_frame);
@@ -222,26 +222,26 @@ void AnimationControllerPrivate::fireEventsAndUpdateStyle()
         m_frame.document()->updateStyleIfNeeded();
 }
 
-void AnimationControllerPrivate::startUpdateStyleIfNeededDispatcher()
+void CSSAnimationControllerPrivate::startUpdateStyleIfNeededDispatcher()
 {
     if (!m_updateStyleIfNeededDispatcher.isActive())
         m_updateStyleIfNeededDispatcher.startOneShot(0);
 }
 
-void AnimationControllerPrivate::addEventToDispatch(Element& element, const AtomicString& eventType, const String& name, double elapsedTime)
+void CSSAnimationControllerPrivate::addEventToDispatch(Element& element, const AtomicString& eventType, const String& name, double elapsedTime)
 {
     m_eventsToDispatch.append({ element, eventType, name, elapsedTime });
     startUpdateStyleIfNeededDispatcher();
 }
 
-void AnimationControllerPrivate::addElementChangeToDispatch(Element& element)
+void CSSAnimationControllerPrivate::addElementChangeToDispatch(Element& element)
 {
     m_elementChangesToDispatch.append(element);
     ASSERT(m_elementChangesToDispatch.last()->document().pageCacheState() == Document::NotInPageCache);
     startUpdateStyleIfNeededDispatcher();
 }
 
-void AnimationControllerPrivate::animationFrameCallbackFired()
+void CSSAnimationControllerPrivate::animationFrameCallbackFired()
 {
     double timeToNextService = updateAnimations(CallSetChanged);
 
@@ -249,7 +249,7 @@ void AnimationControllerPrivate::animationFrameCallbackFired()
         m_frame.document()->view()->scheduleAnimation();
 }
 
-void AnimationControllerPrivate::animationTimerFired()
+void CSSAnimationControllerPrivate::animationTimerFired()
 {
     // We need to keep the frame alive, since it owns us.
     Ref<Frame> protector(m_frame);
@@ -259,7 +259,7 @@ void AnimationControllerPrivate::animationTimerFired()
     AnimationPrivateUpdateBlock updateBlock(*this);
 
     // When the timer fires, all we do is call setChanged on all DOM nodes with running animations and then do an immediate
-    // updateStyleIfNeeded.  It will then call back to us with new information.
+    // updateStyleIfNeeded. It will then call back to us with new information.
     updateAnimationTimer(CallSetChanged);
 
     // Fire events right away, to avoid a flash of unanimated style after an animation completes, and before
@@ -267,7 +267,7 @@ void AnimationControllerPrivate::animationTimerFired()
     fireEventsAndUpdateStyle();
 }
 
-bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool CSSAnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
     ASSERT(renderer.isCSSAnimating());
     ASSERT(m_compositeAnimations.contains(&renderer));
@@ -275,7 +275,7 @@ bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement& ren
     return animation.isAnimatingProperty(property, false, runningState);
 }
 
-bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool CSSAnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
     ASSERT(renderer.isCSSAnimating());
     ASSERT(m_compositeAnimations.contains(&renderer));
@@ -283,7 +283,7 @@ bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderE
     return animation.isAnimatingProperty(property, true, runningState);
 }
 
-void AnimationControllerPrivate::suspendAnimations()
+void CSSAnimationControllerPrivate::suspendAnimations()
 {
     if (isSuspended())
         return;
@@ -297,7 +297,7 @@ void AnimationControllerPrivate::suspendAnimations()
     m_isSuspended = true;
 }
 
-void AnimationControllerPrivate::resumeAnimations()
+void CSSAnimationControllerPrivate::resumeAnimations()
 {
     if (!isSuspended())
         return;
@@ -311,17 +311,17 @@ void AnimationControllerPrivate::resumeAnimations()
     m_isSuspended = false;
 }
 
-bool AnimationControllerPrivate::animationsAreSuspendedForDocument(Document* document)
+bool CSSAnimationControllerPrivate::animationsAreSuspendedForDocument(Document* document)
 {
     return isSuspended() || m_suspendedDocuments.contains(document);
 }
 
-void AnimationControllerPrivate::detachFromDocument(Document* document)
+void CSSAnimationControllerPrivate::detachFromDocument(Document* document)
 {
     m_suspendedDocuments.remove(document);
 }
 
-void AnimationControllerPrivate::suspendAnimationsForDocument(Document* document)
+void CSSAnimationControllerPrivate::suspendAnimationsForDocument(Document* document)
 {
     if (animationsAreSuspendedForDocument(document))
         return;
@@ -338,7 +338,7 @@ void AnimationControllerPrivate::suspendAnimationsForDocument(Document* document
     updateAnimationTimer();
 }
 
-void AnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
+void CSSAnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
 {
     if (!animationsAreSuspendedForDocument(document))
         return;
@@ -355,18 +355,18 @@ void AnimationControllerPrivate::resumeAnimationsForDocument(Document* document)
     updateAnimationTimer();
 }
 
-void AnimationControllerPrivate::startAnimationsIfNotSuspended(Document* document)
+void CSSAnimationControllerPrivate::startAnimationsIfNotSuspended(Document* document)
 {
     if (!animationsAreSuspendedForDocument(document) || allowsNewAnimationsWhileSuspended())
         resumeAnimationsForDocument(document);
 }
 
-void AnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended(bool allowed)
+void CSSAnimationControllerPrivate::setAllowsNewAnimationsWhileSuspended(bool allowed)
 {
     m_allowsNewAnimationsWhileSuspended = allowed;
 }
 
-bool AnimationControllerPrivate::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t)
+bool CSSAnimationControllerPrivate::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t)
 {
     if (!renderer)
         return false;
@@ -381,7 +381,7 @@ bool AnimationControllerPrivate::pauseAnimationAtTime(RenderElement* renderer, c
     return false;
 }
 
-bool AnimationControllerPrivate::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t)
+bool CSSAnimationControllerPrivate::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t)
 {
     if (!renderer)
         return false;
@@ -396,7 +396,7 @@ bool AnimationControllerPrivate::pauseTransitionAtTime(RenderElement* renderer,
     return false;
 }
 
-double AnimationControllerPrivate::beginAnimationUpdateTime()
+double CSSAnimationControllerPrivate::beginAnimationUpdateTime()
 {
     ASSERT(m_beginAnimationUpdateCount);
     if (m_beginAnimationUpdateTime == cBeginAnimationUpdateTimeNotSet)
@@ -405,14 +405,14 @@ double AnimationControllerPrivate::beginAnimationUpdateTime()
     return m_beginAnimationUpdateTime;
 }
 
-void AnimationControllerPrivate::beginAnimationUpdate()
+void CSSAnimationControllerPrivate::beginAnimationUpdate()
 {
     if (!m_beginAnimationUpdateCount)
         setBeginAnimationUpdateTime(cBeginAnimationUpdateTimeNotSet);
     ++m_beginAnimationUpdateCount;
 }
 
-void AnimationControllerPrivate::endAnimationUpdate()
+void CSSAnimationControllerPrivate::endAnimationUpdate()
 {
     ASSERT(m_beginAnimationUpdateCount > 0);
     if (m_beginAnimationUpdateCount == 1) {
@@ -423,15 +423,15 @@ void AnimationControllerPrivate::endAnimationUpdate()
     --m_beginAnimationUpdateCount;
 }
 
-void AnimationControllerPrivate::receivedStartTimeResponse(double time)
+void CSSAnimationControllerPrivate::receivedStartTimeResponse(double time)
 {
-    LOG(Animations, "AnimationControllerPrivate %p receivedStartTimeResponse %f", this, time);
+    LOG(Animations, "CSSAnimationControllerPrivate %p receivedStartTimeResponse %f", this, time);
 
     m_waitingForAsyncStartNotification = false;
     startTimeResponse(time);
 }
 
-std::unique_ptr<RenderStyle> AnimationControllerPrivate::getAnimatedStyleForRenderer(RenderElement& renderer)
+std::unique_ptr<RenderStyle> CSSAnimationControllerPrivate::getAnimatedStyleForRenderer(RenderElement& renderer)
 {
     AnimationPrivateUpdateBlock animationUpdateBlock(*this);
 
@@ -445,7 +445,7 @@ std::unique_ptr<RenderStyle> AnimationControllerPrivate::getAnimatedStyleForRend
     return animatingStyle;
 }
 
-bool AnimationControllerPrivate::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const
+bool CSSAnimationControllerPrivate::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const
 {
     ASSERT(renderer.isCSSAnimating());
     ASSERT(m_compositeAnimations.contains(&renderer));
@@ -457,7 +457,7 @@ bool AnimationControllerPrivate::computeExtentOfAnimation(RenderElement& rendere
     return rendererAnimations.computeExtentOfTransformAnimation(bounds);
 }
 
-unsigned AnimationControllerPrivate::numberOfActiveAnimations(Document* document) const
+unsigned CSSAnimationControllerPrivate::numberOfActiveAnimations(Document* document) const
 {
     unsigned count = 0;
     
@@ -469,7 +469,7 @@ unsigned AnimationControllerPrivate::numberOfActiveAnimations(Document* document
     return count;
 }
 
-void AnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* animation)
+void CSSAnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* animation)
 {
     // Make sure this animation is not in the start time waiters
     m_animationsWaitingForStartTimeResponse.remove(animation);
@@ -477,12 +477,12 @@ void AnimationControllerPrivate::addToAnimationsWaitingForStyle(AnimationBase* a
     m_animationsWaitingForStyle.add(animation);
 }
 
-void AnimationControllerPrivate::removeFromAnimationsWaitingForStyle(AnimationBase* animationToRemove)
+void CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStyle(AnimationBase* animationToRemove)
 {
     m_animationsWaitingForStyle.remove(animationToRemove);
 }
 
-void AnimationControllerPrivate::styleAvailable()
+void CSSAnimationControllerPrivate::styleAvailable()
 {
     // Go through list of waiters and send them on their way
     for (const auto& waitingAnimation : m_animationsWaitingForStyle)
@@ -491,7 +491,7 @@ void AnimationControllerPrivate::styleAvailable()
     m_animationsWaitingForStyle.clear();
 }
 
-void AnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(AnimationBase* animation, bool willGetResponse)
+void CSSAnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(AnimationBase* animation, bool willGetResponse)
 {
     // If willGetResponse is true, it means this animation is actually waiting for a response
     // (which will come in as a call to notifyAnimationStarted()).
@@ -517,7 +517,7 @@ void AnimationControllerPrivate::addToAnimationsWaitingForStartTimeResponse(Anim
     m_animationsWaitingForStartTimeResponse.add(animation);
 }
 
-void AnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse(AnimationBase* animationToRemove)
+void CSSAnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse(AnimationBase* animationToRemove)
 {
     m_animationsWaitingForStartTimeResponse.remove(animationToRemove);
     
@@ -525,7 +525,7 @@ void AnimationControllerPrivate::removeFromAnimationsWaitingForStartTimeResponse
         m_waitingForAsyncStartNotification = false;
 }
 
-void AnimationControllerPrivate::startTimeResponse(double time)
+void CSSAnimationControllerPrivate::startTimeResponse(double time)
 {
     // Go through list of waiters and send them on their way
 
@@ -536,9 +536,9 @@ void AnimationControllerPrivate::startTimeResponse(double time)
     m_waitingForAsyncStartNotification = false;
 }
 
-void AnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation)
+void CSSAnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation)
 {
-    LOG(Animations, "AnimationControllerPrivate %p animationWillBeRemoved: %p", this, animation);
+    LOG(Animations, "CSSAnimationControllerPrivate %p animationWillBeRemoved: %p", this, animation);
 
     removeFromAnimationsWaitingForStyle(animation);
     removeFromAnimationsWaitingForStartTimeResponse(animation);
@@ -559,17 +559,17 @@ void AnimationControllerPrivate::animationWillBeRemoved(AnimationBase* animation
 }
 
 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
-void AnimationControllerPrivate::addToAnimationsDependentOnScroll(AnimationBase* animation)
+void CSSAnimationControllerPrivate::addToAnimationsDependentOnScroll(AnimationBase* animation)
 {
     m_animationsDependentOnScroll.add(animation);
 }
 
-void AnimationControllerPrivate::removeFromAnimationsDependentOnScroll(AnimationBase* animation)
+void CSSAnimationControllerPrivate::removeFromAnimationsDependentOnScroll(AnimationBase* animation)
 {
     m_animationsDependentOnScroll.remove(animation);
 }
 
-void AnimationControllerPrivate::scrollWasUpdated()
+void CSSAnimationControllerPrivate::scrollWasUpdated()
 {
     auto* view = m_frame.view();
     if (!view || !wantsScrollUpdates())
@@ -585,16 +585,16 @@ void AnimationControllerPrivate::scrollWasUpdated()
 }
 #endif
 
-AnimationController::AnimationController(Frame& frame)
-    : m_data(std::make_unique<AnimationControllerPrivate>(frame))
+CSSAnimationController::CSSAnimationController(Frame& frame)
+    : m_data(std::make_unique<CSSAnimationControllerPrivate>(frame))
 {
 }
 
-AnimationController::~AnimationController()
+CSSAnimationController::~CSSAnimationController()
 {
 }
 
-void AnimationController::cancelAnimations(RenderElement& renderer)
+void CSSAnimationController::cancelAnimations(RenderElement& renderer)
 {
     if (!renderer.isCSSAnimating())
         return;
@@ -609,7 +609,7 @@ void AnimationController::cancelAnimations(RenderElement& renderer)
     element->invalidateStyleAndLayerComposition();
 }
 
-bool AnimationController::updateAnimations(RenderElement& renderer, const RenderStyle& newStyle, std::unique_ptr<RenderStyle>& animatedStyle)
+bool CSSAnimationController::updateAnimations(RenderElement& renderer, const RenderStyle& newStyle, std::unique_ptr<RenderStyle>& animatedStyle)
 {
     auto* oldStyle = renderer.hasInitializedStyle() ? &renderer.style() : nullptr;
     if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) && (!newStyle.animations() && !newStyle.transitions()))
@@ -622,9 +622,9 @@ bool AnimationController::updateAnimations(RenderElement& renderer, const Render
     if (renderer.view().printing())
         return false;
 
-    // Fetch our current set of implicit animations from a hashtable.  We then compare them
-    // against the animations in the style and make sure we're in sync.  If destination values
-    // have changed, we reset the animation.  We then do a blend to get new values and we return
+    // Fetch our current set of implicit animations from a hashtable. We then compare them
+    // against the animations in the style and make sure we're in sync. If destination values
+    // have changed, we reset the animation. We then do a blend to get new values and we return
     // a new style.
 
     // We don't support anonymous pseudo elements like :first-line or :first-letter.
@@ -641,14 +641,14 @@ bool AnimationController::updateAnimations(RenderElement& renderer, const Render
     return animationStateChanged;
 }
 
-std::unique_ptr<RenderStyle> AnimationController::getAnimatedStyleForRenderer(RenderElement& renderer)
+std::unique_ptr<RenderStyle> CSSAnimationController::getAnimatedStyleForRenderer(RenderElement& renderer)
 {
     if (!renderer.isCSSAnimating())
         return RenderStyle::clonePtr(renderer.style());
     return m_data->getAnimatedStyleForRenderer(renderer);
 }
 
-bool AnimationController::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const
+bool CSSAnimationController::computeExtentOfAnimation(RenderElement& renderer, LayoutRect& bounds) const
 {
     if (!renderer.isCSSAnimating())
         return true;
@@ -656,98 +656,98 @@ bool AnimationController::computeExtentOfAnimation(RenderElement& renderer, Layo
     return m_data->computeExtentOfAnimation(renderer, bounds);
 }
 
-void AnimationController::notifyAnimationStarted(RenderElement& renderer, double startTime)
+void CSSAnimationController::notifyAnimationStarted(RenderElement& renderer, double startTime)
 {
-    LOG(Animations, "AnimationController %p notifyAnimationStarted on renderer %p, time=%f", this, &renderer, startTime);
+    LOG(Animations, "CSSAnimationController %p notifyAnimationStarted on renderer %p, time=%f", this, &renderer, startTime);
     UNUSED_PARAM(renderer);
 
     AnimationUpdateBlock animationUpdateBlock(this);
     m_data->receivedStartTimeResponse(startTime);
 }
 
-bool AnimationController::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t)
+bool CSSAnimationController::pauseAnimationAtTime(RenderElement* renderer, const AtomicString& name, double t)
 {
     AnimationUpdateBlock animationUpdateBlock(this);
     return m_data->pauseAnimationAtTime(renderer, name, t);
 }
 
-unsigned AnimationController::numberOfActiveAnimations(Document* document) const
+unsigned CSSAnimationController::numberOfActiveAnimations(Document* document) const
 {
     return m_data->numberOfActiveAnimations(document);
 }
 
-bool AnimationController::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t)
+bool CSSAnimationController::pauseTransitionAtTime(RenderElement* renderer, const String& property, double t)
 {
     AnimationUpdateBlock animationUpdateBlock(this);
     return m_data->pauseTransitionAtTime(renderer, property, t);
 }
 
-bool AnimationController::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool CSSAnimationController::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
     return renderer.isCSSAnimating() && m_data->isRunningAnimationOnRenderer(renderer, property, runningState);
 }
 
-bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool CSSAnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
     return renderer.isCSSAnimating() && m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, runningState);
 }
 
-bool AnimationController::isSuspended() const
+bool CSSAnimationController::isSuspended() const
 {
     return m_data->isSuspended();
 }
 
-void AnimationController::suspendAnimations()
+void CSSAnimationController::suspendAnimations()
 {
     LOG(Animations, "controller is suspending animations");
     m_data->suspendAnimations();
 }
 
-void AnimationController::resumeAnimations()
+void CSSAnimationController::resumeAnimations()
 {
     LOG(Animations, "controller is resuming animations");
     m_data->resumeAnimations();
 }
 
-bool AnimationController::allowsNewAnimationsWhileSuspended() const
+bool CSSAnimationController::allowsNewAnimationsWhileSuspended() const
 {
     return m_data->allowsNewAnimationsWhileSuspended();
 }
 
-void AnimationController::setAllowsNewAnimationsWhileSuspended(bool allowed)
+void CSSAnimationController::setAllowsNewAnimationsWhileSuspended(bool allowed)
 {
     m_data->setAllowsNewAnimationsWhileSuspended(allowed);
 }
 
-void AnimationController::serviceAnimations()
+void CSSAnimationController::serviceAnimations()
 {
     m_data->animationFrameCallbackFired();
 }
 
-bool AnimationController::animationsAreSuspendedForDocument(Document* document)
+bool CSSAnimationController::animationsAreSuspendedForDocument(Document* document)
 {
     return m_data->animationsAreSuspendedForDocument(document);
 }
 
-void AnimationController::detachFromDocument(Document* document)
+void CSSAnimationController::detachFromDocument(Document* document)
 {
     return m_data->detachFromDocument(document);
 }
 
-void AnimationController::suspendAnimationsForDocument(Document* document)
+void CSSAnimationController::suspendAnimationsForDocument(Document* document)
 {
     LOG(Animations, "suspending animations for document %p", document);
     m_data->suspendAnimationsForDocument(document);
 }
 
-void AnimationController::resumeAnimationsForDocument(Document* document)
+void CSSAnimationController::resumeAnimationsForDocument(Document* document)
 {
     LOG(Animations, "resuming animations for document %p", document);
     AnimationUpdateBlock animationUpdateBlock(this);
     m_data->resumeAnimationsForDocument(document);
 }
 
-void AnimationController::startAnimationsIfNotSuspended(Document* document)
+void CSSAnimationController::startAnimationsIfNotSuspended(Document* document)
 {
     LOG(Animations, "animations may start for document %p", document);
 
@@ -755,34 +755,34 @@ void AnimationController::startAnimationsIfNotSuspended(Document* document)
     m_data->startAnimationsIfNotSuspended(document);
 }
 
-void AnimationController::beginAnimationUpdate()
+void CSSAnimationController::beginAnimationUpdate()
 {
     m_data->beginAnimationUpdate();
 }
 
-void AnimationController::endAnimationUpdate()
+void CSSAnimationController::endAnimationUpdate()
 {
     m_data->endAnimationUpdate();
 }
 
-bool AnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property)
+bool CSSAnimationController::supportsAcceleratedAnimationOfProperty(CSSPropertyID property)
 {
     return CSSPropertyAnimation::animationOfPropertyIsAccelerated(property);
 }
 
 #if ENABLE(CSS_ANIMATIONS_LEVEL_2)
-bool AnimationController::wantsScrollUpdates() const
+bool CSSAnimationController::wantsScrollUpdates() const
 {
     return m_data->wantsScrollUpdates();
 }
 
-void AnimationController::scrollWasUpdated()
+void CSSAnimationController::scrollWasUpdated()
 {
     m_data->scrollWasUpdated();
 }
 #endif
 
-bool AnimationController::hasAnimations() const
+bool CSSAnimationController::hasAnimations() const
 {
     return m_data->hasAnimations();
 }
@@ -34,7 +34,7 @@
 
 namespace WebCore {
 
-class AnimationControllerPrivate;
+class CSSAnimationControllerPrivate;
 class Document;
 class Element;
 class Frame;
@@ -42,11 +42,11 @@ class LayoutRect;
 class RenderElement;
 class RenderStyle;
 
-class AnimationController {
+class CSSAnimationController {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    explicit AnimationController(Frame&);
-    ~AnimationController();
+    explicit CSSAnimationController(Frame&);
+    ~CSSAnimationController();
 
     void cancelAnimations(RenderElement&);
     bool updateAnimations(RenderElement&, const RenderStyle& newStyle, std::unique_ptr<RenderStyle>& animatedStyle);
@@ -94,12 +94,12 @@ public:
     bool hasAnimations() const;
 
 private:
-    const std::unique_ptr<AnimationControllerPrivate> m_data;
+    const std::unique_ptr<CSSAnimationControllerPrivate> m_data;
 };
 
 class AnimationUpdateBlock {
 public:
-    AnimationUpdateBlock(AnimationController* animationController)
+    AnimationUpdateBlock(CSSAnimationController* animationController)
         : m_animationController(animationController)
     {
         if (m_animationController)
@@ -112,7 +112,7 @@ public:
             m_animationController->endAnimationUpdate();
     }
     
-    AnimationController* m_animationController;
+    CSSAnimationController* m_animationController;
 };
 
 } // namespace WebCore
@@ -42,11 +42,11 @@ class Frame;
 
 enum SetChanged { DoNotCallSetChanged, CallSetChanged };
 
-class AnimationControllerPrivate {
+class CSSAnimationControllerPrivate {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    explicit AnimationControllerPrivate(Frame&);
-    ~AnimationControllerPrivate();
+    explicit CSSAnimationControllerPrivate(Frame&);
+    ~CSSAnimationControllerPrivate();
 
     // Returns the time until the next animation needs to be serviced, or -1 if there are none.
     double updateAnimations(SetChanged callSetChanged = DoNotCallSetChanged);
index ad117a7..98b87c9 100644 (file)
@@ -1290,7 +1290,7 @@ class CSSPropertyAnimationWrapperMap {
 public:
     static CSSPropertyAnimationWrapperMap& singleton()
     {
-        // FIXME: This data is never destroyed. Maybe we should ref count it and toss it when the last AnimationController is destroyed?
+        // FIXME: This data is never destroyed. Maybe we should ref count it and toss it when the last CSSAnimationController is destroyed?
         static NeverDestroyed<CSSPropertyAnimationWrapperMap> map;
         return map;
     }
index 6699270..d1684ee 100644 (file)
@@ -29,7 +29,7 @@
 #include "config.h"
 #include "CompositeAnimation.h"
 
-#include "AnimationControllerPrivate.h"
+#include "CSSAnimationControllerPrivate.h"
 #include "CSSPropertyAnimation.h"
 #include "CSSPropertyNames.h"
 #include "ImplicitAnimation.h"
@@ -42,7 +42,7 @@
 
 namespace WebCore {
 
-CompositeAnimation::CompositeAnimation(AnimationControllerPrivate& animationController)
+CompositeAnimation::CompositeAnimation(CSSAnimationControllerPrivate& animationController)
     : m_animationController(animationController)
 {
     m_suspended = m_animationController.isSuspended() && !m_animationController.allowsNewAnimationsWhileSuspended();
index 40c3a49..f2b7798 100644 (file)
@@ -36,8 +36,8 @@
 
 namespace WebCore {
 
-class AnimationControllerPrivate;
-class AnimationController;
+class CSSAnimationControllerPrivate;
+class CSSAnimationController;
 class RenderElement;
 class RenderStyle;
 
@@ -46,7 +46,7 @@ class RenderStyle;
 class CompositeAnimation : public RefCounted<CompositeAnimation> {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    static Ref<CompositeAnimation> create(AnimationControllerPrivate& animationController)
+    static Ref<CompositeAnimation> create(CSSAnimationControllerPrivate& animationController)
     {
         return adoptRef(*new CompositeAnimation(animationController));
     };
@@ -61,7 +61,7 @@ public:
 
     double timeToNextService() const;
     
-    AnimationControllerPrivate& animationController() const { return m_animationController; }
+    CSSAnimationControllerPrivate& animationController() const { return m_animationController; }
 
     void suspendAnimations();
     void resumeAnimations();
@@ -85,7 +85,7 @@ public:
 #endif
 
 private:
-    CompositeAnimation(AnimationControllerPrivate&);
+    CompositeAnimation(CSSAnimationControllerPrivate&);
 
     void updateTransitions(RenderElement*, const RenderStyle* currentStyle, const RenderStyle* targetStyle);
     void updateKeyframeAnimations(RenderElement*, const RenderStyle* currentStyle, const RenderStyle* targetStyle);
@@ -93,7 +93,7 @@ private:
     typedef HashMap<int, RefPtr<ImplicitAnimation>> CSSPropertyTransitionsMap;
     typedef HashMap<AtomicStringImpl*, RefPtr<KeyframeAnimation>> AnimationNameMap;
 
-    AnimationControllerPrivate& m_animationController;
+    CSSAnimationControllerPrivate& m_animationController;
     CSSPropertyTransitionsMap m_transitions;
     AnimationNameMap m_keyframeAnimations;
     Vector<AtomicStringImpl*> m_keyframeAnimationOrderMap;
index fded623..924eb4b 100644 (file)
  */
 
 #include "config.h"
+#include "ImplicitAnimation.h"
 
-#include "AnimationControllerPrivate.h"
+#include "CSSAnimationControllerPrivate.h"
 #include "CSSPropertyAnimation.h"
 #include "CompositeAnimation.h"
 #include "EventNames.h"
 #include "GeometryUtilities.h"
-#include "ImplicitAnimation.h"
 #include "KeyframeAnimation.h"
 #include "RenderBox.h"
 #include "StylePendingResources.h"
index dc29d22..7e4da6d 100644 (file)
@@ -29,7 +29,7 @@
 #include "config.h"
 #include "KeyframeAnimation.h"
 
-#include "AnimationControllerPrivate.h"
+#include "CSSAnimationControllerPrivate.h"
 #include "CSSPropertyAnimation.h"
 #include "CSSPropertyNames.h"
 #include "CompositeAnimation.h"
index df5e9eb..8355e27 100644 (file)
@@ -27,7 +27,7 @@
 
 #if PLATFORM(IOS)
 
-#import "AnimationController.h"
+#import "CSSAnimationController.h"
 #import "CommonVM.h"
 #import "DOMWindow.h"
 #import "Document.h"
index 68b3aee..35dce4b 100644 (file)
@@ -441,7 +441,7 @@ public:
     static String animationNameForTransition(AnimatedPropertyID);
     
     // Return true if the animation is handled by the compositing system. If this returns
-    // false, the animation will be run by AnimationController.
+    // false, the animation will be run by CSSAnimationController.
     // These methods handle both transitions and keyframe animations.
     virtual bool addAnimation(const KeyframeValueList&, const FloatSize& /*boxSize*/, const Animation*, const String& /*animationName*/, double /*timeOffset*/)  { return false; }
     virtual void pauseAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
index c6f9701..36d0227 100644 (file)
@@ -22,7 +22,7 @@
 
 #pragma once
 
-#include "AnimationController.h"
+#include "CSSAnimationController.h"
 #include "LengthFunctions.h"
 #include "RenderObject.h"
 #include "StyleInheritedData.h"
index 48f1495..7c36853 100644 (file)
@@ -44,8 +44,8 @@
 #include "config.h"
 #include "RenderLayer.h"
 
-#include "AnimationController.h"
 #include "BoxShape.h"
+#include "CSSAnimationController.h"
 #include "CSSPropertyNames.h"
 #include "Chrome.h"
 #include "DebugPageOverlays.h"
index 995f8d7..0e61cff 100644 (file)
@@ -27,7 +27,7 @@
 
 #include "RenderLayerBacking.h"
 
-#include "AnimationController.h"
+#include "CSSAnimationController.h"
 #include "CanvasRenderingContext.h"
 #include "CSSPropertyNames.h"
 #include "CachedImage.h"
index 3c86153..261d173 100644 (file)
@@ -27,7 +27,7 @@
 
 #include "RenderLayerCompositor.h"
 
-#include "AnimationController.h"
+#include "CSSAnimationController.h"
 #include "CanvasRenderingContext.h"
 #include "CSSPropertyNames.h"
 #include "Chrome.h"
@@ -2548,7 +2548,7 @@ bool RenderLayerCompositor::requiresCompositingForAnimation(RenderLayerModelObje
         return false;
 
     const AnimationBase::RunningState activeAnimationState = AnimationBase::Running | AnimationBase::Paused;
-    AnimationController& animController = renderer.animation();
+    CSSAnimationController& animController = renderer.animation();
     return (animController.isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity, activeAnimationState)
             && (inCompositingMode() || (m_compositingTriggers & ChromeClient::AnimatedOpacityTrigger)))
             || animController.isRunningAnimationOnRenderer(renderer, CSSPropertyFilter, activeAnimationState)
index 374f05d..72b876c 100644 (file)
@@ -28,7 +28,7 @@
 #include "RenderObject.h"
 
 #include "AXObjectCache.h"
-#include "AnimationController.h"
+#include "CSSAnimationController.h"
 #include "FloatQuad.h"
 #include "FlowThreadController.h"
 #include "FrameSelection.h"
index 0d9d7cd..18e9f90 100644 (file)
@@ -41,7 +41,7 @@
 namespace WebCore {
 
 class AffineTransform;
-class AnimationController;
+class CSSAnimationController;
 class Color;
 class Cursor;
 class Document;
@@ -771,7 +771,7 @@ public:
     
     void removeFromParent();
 
-    AnimationController& animation() const;
+    CSSAnimationController& animation() const;
 
     // Map points and quads through elements, potentially via 3d transforms. You should never need to call these directly; use
     // localToAbsolute/absoluteToLocal methods instead.
@@ -1016,7 +1016,7 @@ inline Page& RenderObject::page() const
     return *frame().page();
 }
 
-inline AnimationController& RenderObject::animation() const
+inline CSSAnimationController& RenderObject::animation() const
 {
     return frame().animation();
 }
index f5139e2..affacac 100644 (file)
 
 #include "AXObjectCache.h"
 #include "ActiveDOMCallbackMicrotask.h"
-#include "AnimationController.h"
 #include "ApplicationCacheStorage.h"
 #include "Autofill.h"
 #include "BackForwardController.h"
 #include "BitmapImage.h"
+#include "CSSAnimationController.h"
 #include "CSSKeyframesRule.h"
 #include "CSSMediaRule.h"
 #include "CSSStyleRule.h"
index c7a9082..2728869 100644 (file)
@@ -1,3 +1,13 @@
+2017-02-06  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Rename AnimationController to CSSAnimationController
+        https://bugs.webkit.org/show_bug.cgi?id=167829
+
+        Reviewed by Simon Fraser.
+
+        * WebView/WebFrame.mm:
+        * WebView/WebView.mm:
+
 2017-02-03  Chris Dumez  <cdumez@apple.com>
 
         Dismiss HTML form validation popover when pressing Escape key
index 66c944c..ed36e93 100644 (file)
@@ -56,7 +56,7 @@
 #import <JavaScriptCore/JSContextInternal.h>
 #import <WebCore/AXObjectCache.h>
 #import <WebCore/AccessibilityObject.h>
-#import <WebCore/AnimationController.h>
+#import <WebCore/CSSAnimationController.h>
 #import <WebCore/CSSStyleDeclaration.h>
 #import <WebCore/CachedResourceLoader.h>
 #import <WebCore/Chrome.h>
index d20ebac..8f5f316 100644 (file)
 #import <JavaScriptCore/Exception.h>
 #import <JavaScriptCore/JSValueRef.h>
 #import <WebCore/AlternativeTextUIController.h>
-#import <WebCore/AnimationController.h>
 #import <WebCore/ApplicationCacheStorage.h>
 #import <WebCore/BackForwardController.h>
 #import <WebCore/CFNetworkSPI.h>
+#import <WebCore/CSSAnimationController.h>
 #import <WebCore/Chrome.h>
 #import <WebCore/ColorMac.h>
 #import <WebCore/DatabaseManager.h>
index 2f02315..f071e54 100644 (file)
@@ -1,3 +1,12 @@
+2017-02-06  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Rename AnimationController to CSSAnimationController
+        https://bugs.webkit.org/show_bug.cgi?id=167829
+
+        Reviewed by Simon Fraser.
+
+        * WebFrame.cpp:
+
 2017-02-02  Wenson Hsieh  <wenson_hsieh@apple.com>
 
         Drag images should be anchored to the mouse location
index 6cf708f..1a0bb1c 100644 (file)
@@ -52,9 +52,9 @@
 #include "WebScriptWorld.h"
 #include "WebURLResponse.h"
 #include "WebView.h"
-#include <WebCore/AnimationController.h>
 #include <WebCore/BString.h>
 #include <WebCore/COMPtr.h>
+#include <WebCore/CSSAnimationController.h>
 #include <WebCore/MemoryCache.h>
 #include <WebCore/Document.h>
 #include <WebCore/DocumentLoader.h>