☠☠ backed out by d3d970920ea9 ☠ ☠ | |
author | Brian Birtles <birtles@gmail.com> |
Tue, 28 Apr 2015 10:16:45 +0900 | |
changeset 241748 | 1b5fc672f0d457311015f21585b4b512fdf219ba |
parent 241747 | 2bbe38dcb529a5658a3b74542ff726f7403b821a |
child 241749 | 91674f65637c7552e2e81d5148c3334a4b155eb2 |
push id | 28669 |
push user | ryanvm@gmail.com |
push date | Thu, 30 Apr 2015 17:57:05 +0000 |
treeherder | mozilla-central@7723b15ea695 [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | smaug |
bugs | 1159082 |
milestone | 40.0a1 |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- a/dom/animation/Animation.cpp +++ b/dom/animation/Animation.cpp @@ -34,17 +34,17 @@ Animation::WrapObject(JSContext* aCx, JS // --------------------------------------------------------------------------- // // Animation interface: // // --------------------------------------------------------------------------- void -Animation::SetEffect(KeyframeEffectReadonly* aEffect) +Animation::SetEffect(KeyframeEffectReadOnly* aEffect) { if (mEffect) { mEffect->SetParentTime(Nullable<TimeDuration>()); } mEffect = aEffect; if (mEffect) { mEffect->SetParentTime(GetCurrentTime()); }
--- a/dom/animation/Animation.h +++ b/dom/animation/Animation.h @@ -7,17 +7,17 @@ #define mozilla_dom_Animation_h #include "nsWrapperCache.h" #include "nsCycleCollectionParticipant.h" #include "mozilla/Attributes.h" #include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration #include "mozilla/dom/AnimationBinding.h" // for AnimationPlayState #include "mozilla/dom/DocumentTimeline.h" // for DocumentTimeline -#include "mozilla/dom/KeyframeEffect.h" // for KeyframeEffectReadonly +#include "mozilla/dom/KeyframeEffect.h" // for KeyframeEffectReadOnly #include "mozilla/dom/Promise.h" // for Promise #include "nsCSSProperty.h" // for nsCSSProperty // X11 has a #define for CurrentTime. #ifdef CurrentTime #undef CurrentTime #endif @@ -81,18 +81,18 @@ public: */ enum class LimitBehavior { AutoRewind, Continue }; // Animation interface methods - KeyframeEffectReadonly* GetEffect() const { return mEffect; } - void SetEffect(KeyframeEffectReadonly* aEffect); + KeyframeEffectReadOnly* GetEffect() const { return mEffect; } + void SetEffect(KeyframeEffectReadOnly* aEffect); DocumentTimeline* Timeline() const { return mTimeline; } Nullable<TimeDuration> GetStartTime() const { return mStartTime; } void SetStartTime(const Nullable<TimeDuration>& aNewStartTime); Nullable<TimeDuration> GetCurrentTime() const; void SetCurrentTime(const TimeDuration& aNewCurrentTime); double PlaybackRate() const { return mPlaybackRate; } void SetPlaybackRate(double aPlaybackRate); AnimationPlayState PlayState() const; @@ -313,17 +313,17 @@ protected: StickyTimeDuration EffectEnd() const; nsIDocument* GetRenderedDocument() const; nsPresContext* GetPresContext() const; virtual css::CommonAnimationManager* GetAnimationManager() const = 0; AnimationCollection* GetCollection() const; nsRefPtr<DocumentTimeline> mTimeline; - nsRefPtr<KeyframeEffectReadonly> mEffect; + nsRefPtr<KeyframeEffectReadOnly> mEffect; // The beginning of the delay period. Nullable<TimeDuration> mStartTime; // Timeline timescale Nullable<TimeDuration> mHoldTime; // Animation timescale Nullable<TimeDuration> mPendingReadyTime; // Timeline timescale Nullable<TimeDuration> mPreviousCurrentTime; // Animation timescale double mPlaybackRate; // A Promise that is replaced on each call to Play() (and in future Pause())
rename from dom/animation/AnimationEffectReadonly.cpp rename to dom/animation/AnimationEffectReadOnly.cpp --- a/dom/animation/AnimationEffectReadonly.cpp +++ b/dom/animation/AnimationEffectReadOnly.cpp @@ -1,23 +1,23 @@ /* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. */ -#include "mozilla/dom/AnimationEffectReadonly.h" -#include "mozilla/dom/AnimationEffectReadonlyBinding.h" +#include "mozilla/dom/AnimationEffectReadOnly.h" +#include "mozilla/dom/AnimationEffectReadOnlyBinding.h" namespace mozilla { namespace dom { -NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(AnimationEffectReadonly, mParent) +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(AnimationEffectReadOnly, mParent) -NS_IMPL_CYCLE_COLLECTING_ADDREF(AnimationEffectReadonly) -NS_IMPL_CYCLE_COLLECTING_RELEASE(AnimationEffectReadonly) +NS_IMPL_CYCLE_COLLECTING_ADDREF(AnimationEffectReadOnly) +NS_IMPL_CYCLE_COLLECTING_RELEASE(AnimationEffectReadOnly) -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AnimationEffectReadonly) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(AnimationEffectReadOnly) NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY NS_INTERFACE_MAP_ENTRY(nsISupports) NS_INTERFACE_MAP_END } // namespace dom } // namespace mozilla
rename from dom/animation/AnimationEffectReadonly.h rename to dom/animation/AnimationEffectReadOnly.h --- a/dom/animation/AnimationEffectReadonly.h +++ b/dom/animation/AnimationEffectReadOnly.h @@ -9,28 +9,28 @@ #include "nsISupports.h" #include "nsWrapperCache.h" #include "nsCycleCollectionParticipant.h" #include "nsCOMPtr.h" namespace mozilla { namespace dom { -class AnimationEffectReadonly +class AnimationEffectReadOnly : public nsISupports , public nsWrapperCache { protected: - virtual ~AnimationEffectReadonly() { } + virtual ~AnimationEffectReadOnly() { } public: NS_DECL_CYCLE_COLLECTING_ISUPPORTS - NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(AnimationEffectReadonly) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(AnimationEffectReadOnly) - explicit AnimationEffectReadonly(nsISupports* aParent) + explicit AnimationEffectReadOnly(nsISupports* aParent) : mParent(aParent) { } nsISupports* GetParentObject() const { return mParent; } protected: nsCOMPtr<nsISupports> mParent;
--- a/dom/animation/KeyframeEffect.cpp +++ b/dom/animation/KeyframeEffect.cpp @@ -54,45 +54,45 @@ ComputedTimingFunction::GetValue(double } // In the Web Animations model, the time fraction can be outside the range // [0.0, 1.0] but it shouldn't be Infinity. const double ComputedTiming::kNullTimeFraction = PositiveInfinity<double>(); namespace dom { -NS_IMPL_CYCLE_COLLECTION_INHERITED(KeyframeEffectReadonly, - AnimationEffectReadonly, +NS_IMPL_CYCLE_COLLECTION_INHERITED(KeyframeEffectReadOnly, + AnimationEffectReadOnly, mTarget) -NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(KeyframeEffectReadonly, - AnimationEffectReadonly) +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(KeyframeEffectReadOnly, + AnimationEffectReadOnly) NS_IMPL_CYCLE_COLLECTION_TRACE_END -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(KeyframeEffectReadonly) -NS_INTERFACE_MAP_END_INHERITING(AnimationEffectReadonly) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(KeyframeEffectReadOnly) +NS_INTERFACE_MAP_END_INHERITING(AnimationEffectReadOnly) -NS_IMPL_ADDREF_INHERITED(KeyframeEffectReadonly, AnimationEffectReadonly) -NS_IMPL_RELEASE_INHERITED(KeyframeEffectReadonly, AnimationEffectReadonly) +NS_IMPL_ADDREF_INHERITED(KeyframeEffectReadOnly, AnimationEffectReadOnly) +NS_IMPL_RELEASE_INHERITED(KeyframeEffectReadOnly, AnimationEffectReadOnly) JSObject* -KeyframeEffectReadonly::WrapObject(JSContext* aCx, +KeyframeEffectReadOnly::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { - return KeyframeEffectReadonlyBinding::Wrap(aCx, this, aGivenProto); + return KeyframeEffectReadOnlyBinding::Wrap(aCx, this, aGivenProto); } void -KeyframeEffectReadonly::SetParentTime(Nullable<TimeDuration> aParentTime) +KeyframeEffectReadOnly::SetParentTime(Nullable<TimeDuration> aParentTime) { mParentTime = aParentTime; } ComputedTiming -KeyframeEffectReadonly::GetComputedTimingAt( +KeyframeEffectReadOnly::GetComputedTimingAt( const Nullable<TimeDuration>& aLocalTime, const AnimationTiming& aTiming) { const TimeDuration zeroDuration; // Currently we expect negative durations to be picked up during CSS // parsing but when we start receiving timing parameters from other sources // we will need to clamp negative durations here. @@ -212,99 +212,99 @@ KeyframeEffectReadonly::GetComputedTimin if (thisIterationReverse) { result.mTimeFraction = 1.0 - result.mTimeFraction; } return result; } StickyTimeDuration -KeyframeEffectReadonly::ActiveDuration(const AnimationTiming& aTiming) +KeyframeEffectReadOnly::ActiveDuration(const AnimationTiming& aTiming) { if (aTiming.mIterationCount == mozilla::PositiveInfinity<float>()) { // An animation that repeats forever has an infinite active duration // unless its iteration duration is zero, in which case it has a zero // active duration. const StickyTimeDuration zeroDuration; return aTiming.mIterationDuration == zeroDuration ? zeroDuration : StickyTimeDuration::Forever(); } return StickyTimeDuration( aTiming.mIterationDuration.MultDouble(aTiming.mIterationCount)); } // http://w3c.github.io/web-animations/#in-play bool -KeyframeEffectReadonly::IsInPlay(const Animation& aAnimation) const +KeyframeEffectReadOnly::IsInPlay(const Animation& aAnimation) const { if (IsFinishedTransition() || aAnimation.PlayState() == AnimationPlayState::Finished) { return false; } return GetComputedTiming().mPhase == ComputedTiming::AnimationPhase_Active; } // http://w3c.github.io/web-animations/#current bool -KeyframeEffectReadonly::IsCurrent(const Animation& aAnimation) const +KeyframeEffectReadOnly::IsCurrent(const Animation& aAnimation) const { if (IsFinishedTransition() || aAnimation.PlayState() == AnimationPlayState::Finished) { return false; } ComputedTiming computedTiming = GetComputedTiming(); return computedTiming.mPhase == ComputedTiming::AnimationPhase_Before || computedTiming.mPhase == ComputedTiming::AnimationPhase_Active; } bool -KeyframeEffectReadonly::IsInEffect() const +KeyframeEffectReadOnly::IsInEffect() const { if (IsFinishedTransition()) { return false; } ComputedTiming computedTiming = GetComputedTiming(); return computedTiming.mTimeFraction != ComputedTiming::kNullTimeFraction; } const AnimationProperty* -KeyframeEffectReadonly::GetAnimationOfProperty(nsCSSProperty aProperty) const +KeyframeEffectReadOnly::GetAnimationOfProperty(nsCSSProperty aProperty) const { for (size_t propIdx = 0, propEnd = mProperties.Length(); propIdx != propEnd; ++propIdx) { if (aProperty == mProperties[propIdx].mProperty) { const AnimationProperty* result = &mProperties[propIdx]; if (!result->mWinsInCascade) { result = nullptr; } return result; } } return nullptr; } bool -KeyframeEffectReadonly::HasAnimationOfProperties( +KeyframeEffectReadOnly::HasAnimationOfProperties( const nsCSSProperty* aProperties, size_t aPropertyCount) const { for (size_t i = 0; i < aPropertyCount; i++) { if (HasAnimationOfProperty(aProperties[i])) { return true; } } return false; } void -KeyframeEffectReadonly::ComposeStyle( +KeyframeEffectReadOnly::ComposeStyle( nsRefPtr<css::AnimValuesStyleRule>& aStyleRule, nsCSSPropertySet& aSetProperties) { ComputedTiming computedTiming = GetComputedTiming(); // If the time fraction is null, we don't have fill data for the current // time so we shouldn't animate. if (computedTiming.mTimeFraction == ComputedTiming::kNullTimeFraction) {
--- a/dom/animation/KeyframeEffect.h +++ b/dom/animation/KeyframeEffect.h @@ -10,17 +10,17 @@ #include "nsCycleCollectionParticipant.h" #include "nsCSSPseudoElements.h" #include "nsIDocument.h" #include "nsWrapperCache.h" #include "mozilla/Attributes.h" #include "mozilla/StickyTimeDuration.h" #include "mozilla/StyleAnimationValue.h" #include "mozilla/TimeStamp.h" -#include "mozilla/dom/AnimationEffectReadonly.h" +#include "mozilla/dom/AnimationEffectReadOnly.h" #include "mozilla/dom/Element.h" #include "mozilla/dom/Nullable.h" #include "nsSMILKeySpline.h" #include "nsStyleStruct.h" // for nsTimingFunction struct JSContext; class nsCSSPropertySet; @@ -180,47 +180,47 @@ struct AnimationProperty return !(*this == aOther); } }; struct ElementPropertyTransition; namespace dom { -class KeyframeEffectReadonly : public AnimationEffectReadonly +class KeyframeEffectReadOnly : public AnimationEffectReadOnly { public: - KeyframeEffectReadonly(nsIDocument* aDocument, + KeyframeEffectReadOnly(nsIDocument* aDocument, Element* aTarget, nsCSSPseudoElements::Type aPseudoType, const AnimationTiming &aTiming, const nsSubstring& aName) - : AnimationEffectReadonly(aDocument) + : AnimationEffectReadOnly(aDocument) , mTarget(aTarget) , mTiming(aTiming) , mName(aName) , mIsFinishedTransition(false) , mPseudoType(aPseudoType) { MOZ_ASSERT(aTarget, "null animation target is not yet supported"); } NS_DECL_ISUPPORTS_INHERITED - NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(KeyframeEffectReadonly, - AnimationEffectReadonly) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(KeyframeEffectReadOnly, + AnimationEffectReadOnly) virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override; virtual ElementPropertyTransition* AsTransition() { return nullptr; } virtual const ElementPropertyTransition* AsTransition() const { return nullptr; } - // KeyframeEffectReadonly interface + // KeyframeEffectReadOnly interface Element* GetTarget() const { // Currently we only implement Element.getAnimations() which only // returns animations targetting Elements so this should never // be called for an animation that targets a pseudo-element. MOZ_ASSERT(mPseudoType == nsCSSPseudoElements::ePseudo_NotPseudoElement, "Requesting the target of a KeyframeEffect that targets a" " pseudo-element is not yet supported."); return mTarget; @@ -327,17 +327,17 @@ public: // Updates |aStyleRule| with the animation values produced by this // Animation for the current time except any properties already contained // in |aSetProperties|. // Any updated properties are added to |aSetProperties|. void ComposeStyle(nsRefPtr<css::AnimValuesStyleRule>& aStyleRule, nsCSSPropertySet& aSetProperties); protected: - virtual ~KeyframeEffectReadonly() { } + virtual ~KeyframeEffectReadOnly() { } nsCOMPtr<Element> mTarget; Nullable<TimeDuration> mParentTime; AnimationTiming mTiming; nsString mName; // A flag to mark transitions that have finished and are due to // be removed on the next throttle-able cycle.
--- a/dom/animation/moz.build +++ b/dom/animation/moz.build @@ -4,30 +4,30 @@ # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. MOCHITEST_MANIFESTS += ['test/mochitest.ini'] MOCHITEST_CHROME_MANIFESTS += ['test/chrome.ini'] EXPORTS.mozilla.dom += [ 'Animation.h', - 'AnimationEffectReadonly.h', + 'AnimationEffectReadOnly.h', 'AnimationTimeline.h', 'DocumentTimeline.h', 'KeyframeEffect.h', ] EXPORTS.mozilla += [ 'AnimationUtils.h', 'PendingAnimationTracker.h', ] UNIFIED_SOURCES += [ 'Animation.cpp', - 'AnimationEffectReadonly.cpp', + 'AnimationEffectReadOnly.cpp', 'AnimationTimeline.cpp', 'DocumentTimeline.cpp', 'KeyframeEffect.cpp', 'PendingAnimationTracker.cpp', ] FAIL_ON_WARNINGS = True
--- a/dom/base/nsDOMMutationObserver.cpp +++ b/dom/base/nsDOMMutationObserver.cpp @@ -340,17 +340,17 @@ void nsMutationReceiver::NodeWillBeDestr NS_ASSERTION(!mParent, "Shouldn't have mParent here!"); Disconnect(true); } void nsAnimationReceiver::RecordAnimationMutation(Animation* aAnimation, AnimationMutation aMutationType) { - KeyframeEffectReadonly* effect = aAnimation->GetEffect(); + KeyframeEffectReadOnly* effect = aAnimation->GetEffect(); if (!effect) { return; } Element* animationTarget = effect->GetTarget(); if (!animationTarget) { return; }
--- a/dom/base/nsNodeUtils.cpp +++ b/dom/base/nsNodeUtils.cpp @@ -213,17 +213,17 @@ nsNodeUtils::ContentRemoved(nsINode* aCo IMPL_MUTATION_NOTIFICATION(ContentRemoved, aContainer, (document, container, aChild, aIndexInContainer, aPreviousSibling)); } static inline Element* GetTarget(Animation* aAnimation) { - KeyframeEffectReadonly* effect = aAnimation->GetEffect(); + KeyframeEffectReadOnly* effect = aAnimation->GetEffect(); if (!effect) { return nullptr; } Element* target; nsCSSPseudoElements::Type pseudoType; effect->GetTarget(target, pseudoType);
--- a/dom/bindings/Bindings.conf +++ b/dom/bindings/Bindings.conf @@ -83,17 +83,17 @@ DOMInterfaces = { 'MozAbortablePromise': { 'nativeType': 'mozilla::dom::AbortablePromise', }, 'AbstractWorker': { 'concrete': False }, -'AnimationEffectReadonly': { +'AnimationEffectReadOnly': { 'concrete': False }, 'AnimationTimeline': { 'concrete': False }, 'AnonymousContent': {
--- a/dom/tests/mochitest/general/test_interfaces.html +++ b/dom/tests/mochitest/general/test_interfaces.html @@ -127,17 +127,17 @@ var interfaceNamesInGlobalScope = {name: "MozAbortablePromise", pref: "dom.abortablepromise.enabled"}, // IMPORTANT: Do not change this list without review from a DOM peer! {name: "AlarmsManager", pref: "dom.mozAlarms.enabled"}, // IMPORTANT: Do not change this list without review from a DOM peer! "AnalyserNode", // IMPORTANT: Do not change this list without review from a DOM peer! {name: "Animation", pref: "dom.animations-api.core.enabled"}, // IMPORTANT: Do not change this list without review from a DOM peer! - {name: "AnimationEffectReadonly", pref: "dom.animations-api.core.enabled"}, + {name: "AnimationEffectReadOnly", pref: "dom.animations-api.core.enabled"}, // IMPORTANT: Do not change this list without review from a DOM peer! "AnimationEvent", // IMPORTANT: Do not change this list without review from a DOM peer! {name: "AnimationTimeline", pref: "dom.animations-api.core.enabled"}, // IMPORTANT: Do not change this list without review from a DOM peer! "Attr", // IMPORTANT: Do not change this list without review from a DOM peer! "Audio", @@ -646,17 +646,17 @@ var interfaceNamesInGlobalScope = {name: "InputPortManager", b2g: true, pref: "dom.inputport.enabled", permission: ["inputport"]}, // IMPORTANT: Do not change this list without review from a DOM peer! {name: "InstallTrigger", b2g: false}, // IMPORTANT: Do not change this list without review from a DOM peer! "KeyEvent", // IMPORTANT: Do not change this list without review from a DOM peer! "KeyboardEvent", // IMPORTANT: Do not change this list without review from a DOM peer! - {name: "KeyframeEffectReadonly", pref: "dom.animations-api.core.enabled"}, + {name: "KeyframeEffectReadOnly", pref: "dom.animations-api.core.enabled"}, // IMPORTANT: Do not change this list without review from a DOM peer! "LocalMediaStream", // IMPORTANT: Do not change this list without review from a DOM peer! "Location", // IMPORTANT: Do not change this list without review from a DOM peer! "MediaDeviceInfo", // IMPORTANT: Do not change this list without review from a DOM peer! "MediaDevices",
--- a/dom/webidl/Animation.webidl +++ b/dom/webidl/Animation.webidl @@ -11,17 +11,17 @@ */ enum AnimationPlayState { "idle", "pending", "running", "paused", "finished" }; [Func="nsDocument::IsWebAnimationsEnabled"] interface Animation { // Bug 1049975: Make 'effect' writeable [Pure] - readonly attribute AnimationEffectReadonly? effect; + readonly attribute AnimationEffectReadOnly? effect; readonly attribute AnimationTimeline timeline; [BinaryName="startTimeAsDouble"] attribute double? startTime; [SetterThrows, BinaryName="currentTimeAsDouble"] attribute double? currentTime; attribute double playbackRate; [BinaryName="playStateFromJS"]
rename from dom/webidl/AnimationEffectReadonly.webidl rename to dom/webidl/AnimationEffectReadOnly.webidl --- a/dom/webidl/AnimationEffectReadonly.webidl +++ b/dom/webidl/AnimationEffectReadOnly.webidl @@ -6,13 +6,13 @@ * The origin of this IDL file is * http://w3c.github.io/web-animations/#animationeffectreadonly * * Copyright © 2015 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C * liability, trademark and document use rules apply. */ [Func="nsDocument::IsWebAnimationsEnabled"] -interface AnimationEffectReadonly { +interface AnimationEffectReadOnly { // Not yet implemented: - // readonly attribute AnimationEffectTimingReadonly timing; + // readonly attribute AnimationEffectTimingReadOnly timing; // readonly attribute ComputedTimingProperties computedTiming; };
--- a/dom/webidl/KeyframeEffect.webidl +++ b/dom/webidl/KeyframeEffect.webidl @@ -7,17 +7,17 @@ * http://w3c.github.io/web-animations/#the-keyframeeffect-interfaces * * Copyright © 2015 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C * liability, trademark and document use rules apply. */ [HeaderFile="mozilla/dom/KeyframeEffect.h", Func="nsDocument::IsWebAnimationsEnabled"] -interface KeyframeEffectReadonly : AnimationEffectReadonly { +interface KeyframeEffectReadOnly : AnimationEffectReadOnly { readonly attribute Element? target; readonly attribute DOMString name; // Not yet implemented: // readonly attribute IterationCompositeOperation iterationComposite; // readonly attribute CompositeOperation composite; // readonly attribute DOMString spacing; // KeyframeEffect clone(); // sequence<ComputedKeyframe> getFrames ();
--- a/dom/webidl/moz.build +++ b/dom/webidl/moz.build @@ -18,17 +18,17 @@ PREPROCESSED_WEBIDL_FILES = [ WEBIDL_FILES = [ 'AbortablePromise.webidl', 'AbstractWorker.webidl', 'ActivityRequestHandler.webidl', 'AlarmsManager.webidl', 'AnalyserNode.webidl', 'Animatable.webidl', 'Animation.webidl', - 'AnimationEffectReadonly.webidl', + 'AnimationEffectReadOnly.webidl', 'AnimationEvent.webidl', 'AnimationTimeline.webidl', 'AnonymousContent.webidl', 'AppInfo.webidl', 'AppNotificationServiceOptions.webidl', 'Apps.webidl', 'APZTestData.webidl', 'ArchiveReader.webidl',
--- a/gfx/layers/composite/AsyncCompositionManager.cpp +++ b/gfx/layers/composite/AsyncCompositionManager.cpp @@ -8,17 +8,17 @@ #include <stdint.h> // for uint32_t #include "apz/src/AsyncPanZoomController.h" #include "FrameMetrics.h" // for FrameMetrics #include "LayerManagerComposite.h" // for LayerManagerComposite, etc #include "Layers.h" // for Layer, ContainerLayer, etc #include "gfxPoint.h" // for gfxPoint, gfxSize #include "mozilla/StyleAnimationValue.h" // for StyleAnimationValue, etc #include "mozilla/WidgetUtils.h" // for ComputeTransformForRotation -#include "mozilla/dom/KeyframeEffect.h" // for KeyframeEffectReadonly +#include "mozilla/dom/KeyframeEffect.h" // for KeyframeEffectReadOnly #include "mozilla/gfx/BaseRect.h" // for BaseRect #include "mozilla/gfx/Point.h" // for RoundedToInt, PointTyped #include "mozilla/gfx/Rect.h" // for RoundedToInt, RectTyped #include "mozilla/gfx/ScaleFactor.h" // for ScaleFactor #include "mozilla/layers/Compositor.h" // for Compositor #include "mozilla/layers/CompositorParent.h" // for CompositorParent, etc #include "mozilla/layers/LayerMetricsWrapper.h" // for LayerMetricsWrapper #include "nsCoord.h" // for NSAppUnitsToFloatPixels, etc @@ -469,17 +469,17 @@ SampleAnimations(Layer* aLayer, TimeStam timing.mDirection = animation.direction(); // Animations typically only run on the compositor during their active // interval but if we end up sampling them outside that range (for // example, while they are waiting to be removed) we currently just // assume that we should fill. timing.mFillMode = NS_STYLE_ANIMATION_FILL_MODE_BOTH; ComputedTiming computedTiming = - dom::KeyframeEffectReadonly::GetComputedTimingAt( + dom::KeyframeEffectReadOnly::GetComputedTimingAt( Nullable<TimeDuration>(elapsedDuration), timing); MOZ_ASSERT(0.0 <= computedTiming.mTimeFraction && computedTiming.mTimeFraction <= 1.0, "time fraction should be in [0-1]"); int segmentIndex = 0; AnimationSegment* segment = animation.segments().Elements();
--- a/layout/base/nsDisplayList.cpp +++ b/layout/base/nsDisplayList.cpp @@ -421,17 +421,17 @@ AddAnimationsForProperty(nsIFrame* aFram "inconsistent property flags"); // Add from first to last (since last overrides) for (size_t animIdx = 0; animIdx < aAnimations.Length(); animIdx++) { dom::Animation* anim = aAnimations[animIdx]; if (!anim->IsPlaying()) { continue; } - dom::KeyframeEffectReadonly* effect = anim->GetEffect(); + dom::KeyframeEffectReadOnly* effect = anim->GetEffect(); MOZ_ASSERT(effect, "A playing animation should have an effect"); const AnimationProperty* property = effect->GetAnimationOfProperty(aProperty); if (!property) { continue; } // Note that if mWinsInCascade on property was false,
--- a/layout/base/nsLayoutUtils.cpp +++ b/layout/base/nsLayoutUtils.cpp @@ -500,17 +500,17 @@ GetMinAndMaxScaleForAnimationProperty(ns gfxSize& aMaxScale, gfxSize& aMinScale) { for (size_t animIdx = aAnimations->mAnimations.Length(); animIdx-- != 0; ) { dom::Animation* anim = aAnimations->mAnimations[animIdx]; if (!anim->GetEffect() || anim->GetEffect()->IsFinishedTransition()) { continue; } - dom::KeyframeEffectReadonly* effect = anim->GetEffect(); + dom::KeyframeEffectReadOnly* effect = anim->GetEffect(); for (size_t propIdx = effect->Properties().Length(); propIdx-- != 0; ) { AnimationProperty& prop = effect->Properties()[propIdx]; if (prop.mProperty == eCSSProperty_transform) { for (uint32_t segIdx = prop.mSegments.Length(); segIdx-- != 0; ) { AnimationPropertySegment& segment = prop.mSegments[segIdx]; gfxSize from = GetScaleForValue(segment.mFromValue, aContent->GetPrimaryFrame()); aMaxScale.width = std::max<float>(aMaxScale.width, from.width);
--- a/layout/style/AnimationCommon.cpp +++ b/layout/style/AnimationCommon.cpp @@ -25,17 +25,17 @@ #include "RestyleManager.h" #include "nsRuleProcessorData.h" #include "nsStyleSet.h" #include "nsStyleChangeList.h" using mozilla::layers::Layer; using mozilla::dom::Animation; -using mozilla::dom::KeyframeEffectReadonly; +using mozilla::dom::KeyframeEffectReadOnly; namespace mozilla { /* static */ bool IsGeometricProperty(nsCSSProperty aProperty) { switch (aProperty) { case eCSSProperty_bottom: @@ -596,17 +596,17 @@ AnimationCollection::CanPerformOnComposi } for (size_t animIdx = mAnimations.Length(); animIdx-- != 0; ) { const Animation* anim = mAnimations[animIdx]; if (!anim->IsPlaying()) { continue; } - const KeyframeEffectReadonly* effect = anim->GetEffect(); + const KeyframeEffectReadOnly* effect = anim->GetEffect(); MOZ_ASSERT(effect, "A playing animation should have an effect"); for (size_t propIdx = 0, propEnd = effect->Properties().Length(); propIdx != propEnd; ++propIdx) { if (IsGeometricProperty(effect->Properties()[propIdx].mProperty)) { aFlags = CanAnimateFlags(aFlags | CanAnimate_HasGeometricProperty); break; } @@ -615,17 +615,17 @@ AnimationCollection::CanPerformOnComposi bool existsProperty = false; for (size_t animIdx = mAnimations.Length(); animIdx-- != 0; ) { const Animation* anim = mAnimations[animIdx]; if (!anim->IsPlaying()) { continue; } - const KeyframeEffectReadonly* effect = anim->GetEffect(); + const KeyframeEffectReadOnly* effect = anim->GetEffect(); MOZ_ASSERT(effect, "A playing animation should have an effect"); existsProperty = existsProperty || effect->Properties().Length() > 0; for (size_t propIdx = 0, propEnd = effect->Properties().Length(); propIdx != propEnd; ++propIdx) { const AnimationProperty& prop = effect->Properties()[propIdx]; if (!CanAnimatePropertyOnCompositor(mElement, @@ -668,17 +668,17 @@ AnimationCollection::PostUpdateLayerAnim } } } bool AnimationCollection::HasAnimationOfProperty(nsCSSProperty aProperty) const { for (size_t animIdx = mAnimations.Length(); animIdx-- != 0; ) { - const KeyframeEffectReadonly* effect = mAnimations[animIdx]->GetEffect(); + const KeyframeEffectReadOnly* effect = mAnimations[animIdx]->GetEffect(); if (effect && effect->HasAnimationOfProperty(aProperty) && !effect->IsFinishedTransition()) { return true; } } return false; } @@ -917,17 +917,17 @@ AnimationCollection::HasCurrentAnimation bool AnimationCollection::HasCurrentAnimationsForProperties( const nsCSSProperty* aProperties, size_t aPropertyCount) const { for (size_t animIdx = mAnimations.Length(); animIdx-- != 0; ) { const Animation& anim = *mAnimations[animIdx]; - const KeyframeEffectReadonly* effect = anim.GetEffect(); + const KeyframeEffectReadOnly* effect = anim.GetEffect(); if (effect && effect->IsCurrent(anim) && effect->HasAnimationOfProperties(aProperties, aPropertyCount)) { return true; } } return false;
--- a/layout/style/nsAnimationManager.cpp +++ b/layout/style/nsAnimationManager.cpp @@ -21,17 +21,17 @@ #include "nsIDocument.h" #include "nsDOMMutationObserver.h" #include <math.h> using namespace mozilla; using namespace mozilla::css; using mozilla::dom::Animation; using mozilla::dom::AnimationPlayState; -using mozilla::dom::KeyframeEffectReadonly; +using mozilla::dom::KeyframeEffectReadOnly; using mozilla::CSSAnimation; mozilla::dom::Promise* CSSAnimation::GetReady(ErrorResult& aRv) { FlushStyle(); return Animation::GetReady(aRv); } @@ -347,18 +347,18 @@ nsAnimationManager::CheckAnimationRule(n continue; } bool animationChanged = false; // Update the old from the new so we can keep the original object // identity (and any expando properties attached to it). if (oldAnim->GetEffect() && newAnim->GetEffect()) { - KeyframeEffectReadonly* oldEffect = oldAnim->GetEffect(); - KeyframeEffectReadonly* newEffect = newAnim->GetEffect(); + KeyframeEffectReadOnly* oldEffect = oldAnim->GetEffect(); + KeyframeEffectReadOnly* newEffect = newAnim->GetEffect(); animationChanged = oldEffect->Timing() != newEffect->Timing() || oldEffect->Properties() != newEffect->Properties(); oldEffect->Timing() = newEffect->Timing(); oldEffect->Properties() = newEffect->Properties(); } // Reset compositor state so animation will be re-synchronized. @@ -521,18 +521,18 @@ nsAnimationManager::BuildAnimations(nsSt AnimationTiming timing; timing.mIterationDuration = TimeDuration::FromMilliseconds(src.GetDuration()); timing.mDelay = TimeDuration::FromMilliseconds(src.GetDelay()); timing.mIterationCount = src.GetIterationCount(); timing.mDirection = src.GetDirection(); timing.mFillMode = src.GetFillMode(); - nsRefPtr<KeyframeEffectReadonly> destEffect = - new KeyframeEffectReadonly(mPresContext->Document(), aTarget, + nsRefPtr<KeyframeEffectReadOnly> destEffect = + new KeyframeEffectReadOnly(mPresContext->Document(), aTarget, aStyleContext->GetPseudoType(), timing, src.GetName()); dest->SetEffect(destEffect); // Even in the case where we call PauseFromStyle below, we still need to // call PlayFromStyle first. This is because a newly-created animation is // idle and has no effect until it is played (or otherwise given a start // time). @@ -749,17 +749,17 @@ nsAnimationManager::UpdateCascadeResults nsAutoTArray<nsCSSProperty, 2> propertiesToTrack; { nsCSSPropertySet propertiesToTrackAsSet; for (size_t animIdx = aElementAnimations->mAnimations.Length(); animIdx-- != 0; ) { const Animation* anim = aElementAnimations->mAnimations[animIdx]; - const KeyframeEffectReadonly* effect = anim->GetEffect(); + const KeyframeEffectReadOnly* effect = anim->GetEffect(); if (!effect) { continue; } for (size_t propIdx = 0, propEnd = effect->Properties().Length(); propIdx != propEnd; ++propIdx) { const AnimationProperty& prop = effect->Properties()[propIdx]; // We only bother setting mWinsInCascade for properties that we @@ -797,17 +797,17 @@ nsAnimationManager::UpdateCascadeResults * currently in effect. */ bool changed = false; for (size_t animIdx = aElementAnimations->mAnimations.Length(); animIdx-- != 0; ) { CSSAnimation* anim = aElementAnimations->mAnimations[animIdx]->AsCSSAnimation(); - KeyframeEffectReadonly* effect = anim->GetEffect(); + KeyframeEffectReadOnly* effect = anim->GetEffect(); anim->mInEffectForCascadeResults = anim->IsInEffect(); if (!effect) { continue; } for (size_t propIdx = 0, propEnd = effect->Properties().Length();
--- a/layout/style/nsTransitionManager.cpp +++ b/layout/style/nsTransitionManager.cpp @@ -29,29 +29,29 @@ #include "nsStyleChangeList.h" #include "nsStyleSet.h" #include "RestyleManager.h" #include "nsDOMMutationObserver.h" using mozilla::TimeStamp; using mozilla::TimeDuration; using mozilla::dom::Animation; -using mozilla::dom::KeyframeEffectReadonly; +using mozilla::dom::KeyframeEffectReadOnly; using namespace mozilla; using namespace mozilla::css; const nsString& ElementPropertyTransition::Name() const { if (!mName.Length()) { const_cast<ElementPropertyTransition*>(this)->mName = NS_ConvertUTF8toUTF16(nsCSSProps::GetStringValue(TransitionProperty())); } - return dom::KeyframeEffectReadonly::Name(); + return dom::KeyframeEffectReadOnly::Name(); } double ElementPropertyTransition::CurrentValuePortion() const { // It would be easy enough to handle finished transitions by using a time // fraction of 1 but currently we should not be called for finished // transitions. @@ -316,17 +316,17 @@ nsTransitionManager::StyleContextChanged AnimationPtrArray& animations = collection->mAnimations; size_t i = animations.Length(); MOZ_ASSERT(i != 0, "empty transitions list?"); StyleAnimationValue currentValue; do { --i; Animation* anim = animations[i]; - dom::KeyframeEffectReadonly* effect = anim->GetEffect(); + dom::KeyframeEffectReadOnly* effect = anim->GetEffect(); MOZ_ASSERT(effect && effect->Properties().Length() == 1, "Should have one animation property for a transition"); MOZ_ASSERT(effect && effect->Properties()[0].mSegments.Length() == 1, "Animation property should have one segment for a transition"); const AnimationProperty& prop = effect->Properties()[0]; const AnimationPropertySegment& segment = prop.mSegments[0]; // properties no longer in 'transition-property' if ((checkProperties && @@ -628,17 +628,17 @@ nsTransitionManager::PruneCompletedTrans // FIXME (bug 1158431): Really, we should also cancel running // transitions whose destination doesn't match as well. AnimationPtrArray& animations = collection->mAnimations; size_t i = animations.Length(); MOZ_ASSERT(i != 0, "empty transitions list?"); do { --i; Animation* anim = animations[i]; - dom::KeyframeEffectReadonly* effect = anim->GetEffect(); + dom::KeyframeEffectReadOnly* effect = anim->GetEffect(); if (!effect->IsFinishedTransition()) { continue; } MOZ_ASSERT(effect && effect->Properties().Length() == 1, "Should have one animation property for a transition"); MOZ_ASSERT(effect && effect->Properties()[0].mSegments.Length() == 1,
--- a/layout/style/nsTransitionManager.h +++ b/layout/style/nsTransitionManager.h @@ -24,23 +24,23 @@ struct StyleTransition; } /***************************************************************************** * Per-Element data * *****************************************************************************/ namespace mozilla { -struct ElementPropertyTransition : public dom::KeyframeEffectReadonly +struct ElementPropertyTransition : public dom::KeyframeEffectReadOnly { ElementPropertyTransition(nsIDocument* aDocument, dom::Element* aTarget, nsCSSPseudoElements::Type aPseudoType, const AnimationTiming &aTiming) - : dom::KeyframeEffectReadonly(aDocument, aTarget, aPseudoType, + : dom::KeyframeEffectReadOnly(aDocument, aTarget, aPseudoType, aTiming, EmptyString()) { } virtual ElementPropertyTransition* AsTransition() override { return this; } virtual const ElementPropertyTransition* AsTransition() const override { return this; } virtual const nsString& Name() const override;