dom/svg/SVGAnimatedPathSegList.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 "SVGAnimatedPathSegList.h"
   8
   9 #include <utility>
  10
  11 #include "DOMSVGPathSegList.h"
  12 #include "SVGPathSegListSMILType.h"
  13 #include "mozilla/SMILValue.h"
  14 #include "mozilla/StaticPrefs_dom.h"
  15 #include "mozilla/dom/SVGElement.h"
  16
  17 using namespace mozilla::dom;
  18
  19 // See the comments in this file's header!
  20
  21 namespace mozilla {
  22
  23 nsresult SVGAnimatedPathSegList::SetBaseValueString(const nsAString& aValue) {
  24   SVGPathData newBaseValue;
  25
  26   // The spec says that the path data is parsed and accepted up to the first
  27   // error encountered, so we don't return early if an error occurs. However,
  28   // we do want to throw any error code from setAttribute if there's a problem.
  29   nsresult rv = newBaseValue.SetValueFromString(aValue);
  30
  31   // We must send these notifications *before* changing mBaseVal! Our baseVal's
  32   // DOM wrapper list may have to remove DOM items from itself, and any removed
  33   // DOM items need to copy their internal counterpart's values *before* we
  34   // change them. See the comments in
  35   // DOMSVGPathSegList::InternalListWillChangeTo().
  36   DOMSVGPathSegList* baseValWrapper = nullptr;
  37   DOMSVGPathSegList* animValWrapper = nullptr;
  38   if (StaticPrefs::dom_svg_pathSeg_enabled()) {
  39     baseValWrapper = DOMSVGPathSegList::GetDOMWrapperIfExists(GetBaseValKey());
  40     if (baseValWrapper) {
  41       baseValWrapper->InternalListWillChangeTo(newBaseValue);
  42     }
  43
  44     if (!IsAnimating()) {  // DOM anim val wraps our base val too!
  45       animValWrapper =
  46           DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
  47       if (animValWrapper) {
  48         animValWrapper->InternalListWillChangeTo(newBaseValue);
  49       }
  50     }
  51   }
  52
  53   // Only now may we modify mBaseVal!
  54
  55   // We don't need to call DidChange* here - we're only called by
  56   // SVGElement::ParseAttribute under Element::SetAttr,
  57   // which takes care of notifying.
  58
  59   mBaseVal.SwapWith(newBaseValue);
  60   return rv;
  61 }
  62
  63 void SVGAnimatedPathSegList::ClearBaseValue() {
  64   if (StaticPrefs::dom_svg_pathSeg_enabled()) {
  65     // We must send these notifications *before* changing mBaseVal! (See above.)
  66
  67     DOMSVGPathSegList* baseValWrapper =
  68         DOMSVGPathSegList::GetDOMWrapperIfExists(GetBaseValKey());
  69     if (baseValWrapper) {
  70       baseValWrapper->InternalListWillChangeTo(SVGPathData());
  71     }
  72
  73     if (!IsAnimating()) {  // DOM anim val wraps our base val too!
  74       DOMSVGPathSegList* animValWrapper =
  75           DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
  76       if (animValWrapper) {
  77         animValWrapper->InternalListWillChangeTo(SVGPathData());
  78       }
  79     }
  80   }
  81
  82   mBaseVal.Clear();
  83   // Caller notifies
  84 }
  85
  86 nsresult SVGAnimatedPathSegList::SetAnimValue(const SVGPathData& aNewAnimValue,
  87                                               SVGElement* aElement) {
  88   // Note that a new animation may totally change the number of items in the
  89   // animVal list, either replacing what was essentially a mirror of the
  90   // baseVal list, or else replacing and overriding an existing animation.
  91   // Unfortunately it is not possible for us to reliably distinguish between
  92   // calls to this method that are setting a new sample for an existing
  93   // animation, and calls that are setting the first sample of an animation
  94   // that will override an existing animation. In the case of DOMSVGPathSegList
  95   // the InternalListWillChangeTo method is not virtually free as it is for the
  96   // other DOM list classes, so this is a shame. We'd quite like to be able to
  97   // skip the call if possible.
  98
  99   if (StaticPrefs::dom_svg_pathSeg_enabled()) {
 100     // We must send these notifications *before* changing mAnimVal! (See above.)
 101
 102     DOMSVGPathSegList* domWrapper =
 103         DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
 104     if (domWrapper) {
 105       domWrapper->InternalListWillChangeTo(aNewAnimValue);
 106     }
 107   }
 108   if (!mAnimVal) {
 109     mAnimVal = MakeUnique<SVGPathData>();
 110   }
 111   nsresult rv = mAnimVal->CopyFrom(aNewAnimValue);
 112   if (NS_FAILED(rv)) {
 113     // OOM. We clear the animation and, importantly, ClearAnimValue() ensures
 114     // that mAnimVal's DOM wrapper (if any) is kept in sync!
 115     ClearAnimValue(aElement);
 116   }
 117   aElement->DidAnimatePathSegList();
 118   return rv;
 119 }
 120
 121 void SVGAnimatedPathSegList::ClearAnimValue(SVGElement* aElement) {
 122   if (StaticPrefs::dom_svg_pathSeg_enabled()) {
 123     // We must send these notifications *before* changing mAnimVal! (See above.)
 124
 125     DOMSVGPathSegList* domWrapper =
 126         DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
 127     if (domWrapper) {
 128       // When all animation ends, animVal simply mirrors baseVal, which may have
 129       // a different number of items to the last active animated value.
 130       //
 131       domWrapper->InternalListWillChangeTo(mBaseVal);
 132     }
 133   }
 134   mAnimVal = nullptr;
 135   aElement->DidAnimatePathSegList();
 136 }
 137
 138 bool SVGAnimatedPathSegList::IsRendered() const {
 139   return mAnimVal ? !mAnimVal->IsEmpty() : !mBaseVal.IsEmpty();
 140 }
 141
 142 UniquePtr<SMILAttr> SVGAnimatedPathSegList::ToSMILAttr(SVGElement* aElement) {
 143   return MakeUnique<SMILAnimatedPathSegList>(this, aElement);
 144 }
 145
 146 nsresult SVGAnimatedPathSegList::SMILAnimatedPathSegList::ValueFromString(
 147     const nsAString& aStr, const dom::SVGAnimationElement* /*aSrcElement*/,
 148     SMILValue& aValue, bool& aPreventCachingOfSandwich) const {
 149   SMILValue val(SVGPathSegListSMILType::Singleton());
 150   SVGPathDataAndInfo* list = static_cast<SVGPathDataAndInfo*>(val.mU.mPtr);
 151   nsresult rv = list->SetValueFromString(aStr);
 152   if (NS_SUCCEEDED(rv)) {
 153     list->SetElement(mElement);
 154     aValue = std::move(val);
 155   }
 156   return rv;
 157 }
 158
 159 SMILValue SVGAnimatedPathSegList::SMILAnimatedPathSegList::GetBaseValue()
 160     const {
 161   // To benefit from Return Value Optimization and avoid copy constructor calls
 162   // due to our use of return-by-value, we must return the exact same object
 163   // from ALL return points. This function must only return THIS variable:
 164   SMILValue val;
 165
 166   SMILValue tmp(SVGPathSegListSMILType::Singleton());
 167   auto* list = static_cast<SVGPathDataAndInfo*>(tmp.mU.mPtr);
 168   nsresult rv = list->CopyFrom(mVal->mBaseVal);
 169   if (NS_SUCCEEDED(rv)) {
 170     list->SetElement(mElement);
 171     val = std::move(tmp);
 172   }
 173   return val;
 174 }
 175
 176 nsresult SVGAnimatedPathSegList::SMILAnimatedPathSegList::SetAnimValue(
 177     const SMILValue& aValue) {
 178   NS_ASSERTION(aValue.mType == SVGPathSegListSMILType::Singleton(),
 179                "Unexpected type to assign animated value");
 180   if (aValue.mType == SVGPathSegListSMILType::Singleton()) {
 181     mVal->SetAnimValue(*static_cast<SVGPathDataAndInfo*>(aValue.mU.mPtr),
 182                        mElement);
 183   }
 184   return NS_OK;
 185 }
 186
 187 void SVGAnimatedPathSegList::SMILAnimatedPathSegList::ClearAnimValue() {
 188   if (mVal->mAnimVal) {
 189     mVal->ClearAnimValue(mElement);
 190   }
 191 }
 192
 193 size_t SVGAnimatedPathSegList::SizeOfExcludingThis(
 194     MallocSizeOf aMallocSizeOf) const {
 195   size_t total = mBaseVal.SizeOfExcludingThis(aMallocSizeOf);
 196   if (mAnimVal) {
 197     mAnimVal->SizeOfIncludingThis(aMallocSizeOf);
 198   }
 199   return total;
 200 }
 201
 202 }  // namespace mozilla