dom/animation/EffectSet.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "EffectSet.h"
   8 #include "mozilla/dom/Element.h"  // For Element
   9 #include "mozilla/RestyleManager.h"
  10 #include "mozilla/LayerAnimationInfo.h"
  11 #include "nsCSSPseudoElements.h"         // For PseudoStyleType
  12 #include "nsCycleCollectionNoteChild.h"  // For CycleCollectionNoteChild
  13 #include "nsPresContext.h"
  14 #include "nsLayoutUtils.h"
  15
  16 namespace mozilla {
  17
  18 /* static */
  19 void EffectSet::PropertyDtor(void* aObject, nsAtom* aPropertyName,
  20                              void* aPropertyValue, void* aData) {
  21   EffectSet* effectSet = static_cast<EffectSet*>(aPropertyValue);
  22
  23 #ifdef DEBUG
  24   MOZ_ASSERT(!effectSet->mCalledPropertyDtor, "Should not call dtor twice");
  25   effectSet->mCalledPropertyDtor = true;
  26 #endif
  27
  28   delete effectSet;
  29 }
  30
  31 void EffectSet::Traverse(nsCycleCollectionTraversalCallback& aCallback) {
  32   for (const auto& key : mEffects) {
  33     CycleCollectionNoteChild(aCallback, key, "EffectSet::mEffects[]",
  34                              aCallback.Flags());
  35   }
  36 }
  37
  38 /* static */
  39 EffectSet* EffectSet::GetEffectSet(const dom::Element* aElement,
  40                                    PseudoStyleType aPseudoType) {
  41   if (!aElement->MayHaveAnimations()) {
  42     return nullptr;
  43   }
  44
  45   nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
  46   return static_cast<EffectSet*>(aElement->GetProperty(propName));
  47 }
  48
  49 /* static */
  50 EffectSet* EffectSet::GetOrCreateEffectSet(dom::Element* aElement,
  51                                            PseudoStyleType aPseudoType) {
  52   EffectSet* effectSet = GetEffectSet(aElement, aPseudoType);
  53   if (effectSet) {
  54     return effectSet;
  55   }
  56
  57   nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
  58   effectSet = new EffectSet();
  59
  60   nsresult rv = aElement->SetProperty(propName, effectSet,
  61                                       &EffectSet::PropertyDtor, true);
  62   if (NS_FAILED(rv)) {
  63     NS_WARNING("SetProperty failed");
  64     // The set must be destroyed via PropertyDtor, otherwise
  65     // mCalledPropertyDtor assertion is triggered in destructor.
  66     EffectSet::PropertyDtor(aElement, propName, effectSet, nullptr);
  67     return nullptr;
  68   }
  69
  70   aElement->SetMayHaveAnimations();
  71
  72   return effectSet;
  73 }
  74
  75 /* static */
  76 EffectSet* EffectSet::GetEffectSetForFrame(
  77     const nsIFrame* aFrame, const nsCSSPropertyIDSet& aProperties) {
  78   MOZ_ASSERT(aFrame);
  79
  80   // Transform animations are run on the primary frame (but stored on the
  81   // content associated with the style frame).
  82   const nsIFrame* frameToQuery = nullptr;
  83   if (aProperties.IsSubsetOf(nsCSSPropertyIDSet::TransformLikeProperties())) {
  84     // Make sure to return nullptr if we're looking for transform animations on
  85     // the inner table frame.
  86     if (!aFrame->IsFrameOfType(nsIFrame::eSupportsCSSTransforms)) {
  87       return nullptr;
  88     }
  89     frameToQuery = nsLayoutUtils::GetStyleFrame(aFrame);
  90   } else {
  91     MOZ_ASSERT(
  92         !aProperties.Intersects(nsCSSPropertyIDSet::TransformLikeProperties()),
  93         "We should have only transform properties or no transform properties");
  94     // We don't need to explicitly return nullptr when |aFrame| is NOT the style
  95     // frame since there will be no effect set in that case.
  96     frameToQuery = aFrame;
  97   }
  98
  99   Maybe<NonOwningAnimationTarget> target =
 100       EffectCompositor::GetAnimationElementAndPseudoForFrame(frameToQuery);
 101   if (!target) {
 102     return nullptr;
 103   }
 104
 105   return GetEffectSet(target->mElement, target->mPseudoType);
 106 }
 107
 108 /* static */
 109 EffectSet* EffectSet::GetEffectSetForFrame(const nsIFrame* aFrame,
 110                                            DisplayItemType aDisplayItemType) {
 111   return EffectSet::GetEffectSetForFrame(
 112       aFrame, LayerAnimationInfo::GetCSSPropertiesFor(aDisplayItemType));
 113 }
 114
 115 /* static */
 116 EffectSet* EffectSet::GetEffectSetForStyleFrame(const nsIFrame* aStyleFrame) {
 117   Maybe<NonOwningAnimationTarget> target =
 118       EffectCompositor::GetAnimationElementAndPseudoForFrame(aStyleFrame);
 119
 120   if (!target) {
 121     return nullptr;
 122   }
 123
 124   return GetEffectSet(target->mElement, target->mPseudoType);
 125 }
 126
 127 /* static */
 128 EffectSet* EffectSet::GetEffectSetForEffect(
 129     const dom::KeyframeEffect* aEffect) {
 130   NonOwningAnimationTarget target = aEffect->GetAnimationTarget();
 131   if (!target) {
 132     return nullptr;
 133   }
 134
 135   return EffectSet::GetEffectSet(target.mElement, target.mPseudoType);
 136 }
 137
 138 /* static */
 139 void EffectSet::DestroyEffectSet(dom::Element* aElement,
 140                                  PseudoStyleType aPseudoType) {
 141   nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
 142   EffectSet* effectSet =
 143       static_cast<EffectSet*>(aElement->GetProperty(propName));
 144   if (!effectSet) {
 145     return;
 146   }
 147
 148   MOZ_ASSERT(!effectSet->IsBeingEnumerated(),
 149              "Should not destroy an effect set while it is being enumerated");
 150   effectSet = nullptr;
 151
 152   aElement->RemoveProperty(propName);
 153 }
 154
 155 void EffectSet::UpdateAnimationGeneration(nsPresContext* aPresContext) {
 156   mAnimationGeneration =
 157       aPresContext->RestyleManager()->GetAnimationGeneration();
 158 }
 159
 160 /* static */
 161 nsAtom** EffectSet::GetEffectSetPropertyAtoms() {
 162   static nsAtom* effectSetPropertyAtoms[] = {
 163       nsGkAtoms::animationEffectsProperty,
 164       nsGkAtoms::animationEffectsForBeforeProperty,
 165       nsGkAtoms::animationEffectsForAfterProperty,
 166       nsGkAtoms::animationEffectsForMarkerProperty, nullptr};
 167
 168   return effectSetPropertyAtoms;
 169 }
 170
 171 /* static */
 172 nsAtom* EffectSet::GetEffectSetPropertyAtom(PseudoStyleType aPseudoType) {
 173   switch (aPseudoType) {
 174     case PseudoStyleType::NotPseudo:
 175       return nsGkAtoms::animationEffectsProperty;
 176
 177     case PseudoStyleType::before:
 178       return nsGkAtoms::animationEffectsForBeforeProperty;
 179
 180     case PseudoStyleType::after:
 181       return nsGkAtoms::animationEffectsForAfterProperty;
 182
 183     case PseudoStyleType::marker:
 184       return nsGkAtoms::animationEffectsForMarkerProperty;
 185
 186     default:
 187       MOZ_ASSERT_UNREACHABLE(
 188           "Should not try to get animation effects for "
 189           "a pseudo other that :before, :after or ::marker");
 190       return nullptr;
 191   }
 192 }
 193
 194 void EffectSet::AddEffect(dom::KeyframeEffect& aEffect) {
 195   if (!mEffects.EnsureInserted(&aEffect)) {
 196     return;
 197   }
 198
 199   MarkCascadeNeedsUpdate();
 200 }
 201
 202 void EffectSet::RemoveEffect(dom::KeyframeEffect& aEffect) {
 203   if (!mEffects.EnsureRemoved(&aEffect)) {
 204     return;
 205   }
 206
 207   MarkCascadeNeedsUpdate();
 208 }
 209
 210 }  // namespace mozilla