gecko-dev/dom/svg/SVGAnimatedPathSegList.cpp
Brian Birtles 8ff0648aee Bug 1353208 - Use UniquePtr for handling heap-allocated nsISMILAttr objects; r=dholbert
MozReview-Commit-ID: 10lA0ZaXChj

--HG--
extra : rebase_source : f5285b5363b2247ac73f63d9d13f8a109728a7c2
2017-03-30 13:10:07 +09:00

220 lines
7.1 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "SVGAnimatedPathSegList.h"
#include "DOMSVGPathSegList.h"
#include "mozilla/Move.h"
#include "nsSVGElement.h"
#include "nsSVGAttrTearoffTable.h"
#include "nsSMILValue.h"
#include "SVGPathSegListSMILType.h"
// See the comments in this file's header!
namespace mozilla {
nsresult
SVGAnimatedPathSegList::SetBaseValueString(const nsAString& aValue)
{
SVGPathData newBaseValue;
// The spec says that the path data is parsed and accepted up to the first
// error encountered, so we don't return early if an error occurs. However,
// we do want to throw any error code from setAttribute if there's a problem.
nsresult rv = newBaseValue.SetValueFromString(aValue);
// We must send these notifications *before* changing mBaseVal! Our baseVal's
// DOM wrapper list may have to remove DOM items from itself, and any removed
// DOM items need to copy their internal counterpart's values *before* we
// change them. See the comments in
// DOMSVGPathSegList::InternalListWillChangeTo().
DOMSVGPathSegList *baseValWrapper =
DOMSVGPathSegList::GetDOMWrapperIfExists(GetBaseValKey());
if (baseValWrapper) {
baseValWrapper->InternalListWillChangeTo(newBaseValue);
}
DOMSVGPathSegList* animValWrapper = nullptr;
if (!IsAnimating()) { // DOM anim val wraps our base val too!
animValWrapper = DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
if (animValWrapper) {
animValWrapper->InternalListWillChangeTo(newBaseValue);
}
}
// Only now may we modify mBaseVal!
// We don't need to call DidChange* here - we're only called by
// nsSVGElement::ParseAttribute under Element::SetAttr,
// which takes care of notifying.
nsresult rv2 = mBaseVal.CopyFrom(newBaseValue);
if (NS_FAILED(rv2)) {
// Attempting to increase mBaseVal's length failed (mBaseVal is left
// unmodified). We MUST keep any DOM wrappers in sync:
if (baseValWrapper) {
baseValWrapper->InternalListWillChangeTo(mBaseVal);
}
if (animValWrapper) {
animValWrapper->InternalListWillChangeTo(mBaseVal);
}
return rv2;
}
return rv;
}
void
SVGAnimatedPathSegList::ClearBaseValue()
{
// We must send these notifications *before* changing mBaseVal! (See above.)
DOMSVGPathSegList *baseValWrapper =
DOMSVGPathSegList::GetDOMWrapperIfExists(GetBaseValKey());
if (baseValWrapper) {
baseValWrapper->InternalListWillChangeTo(SVGPathData());
}
if (!IsAnimating()) { // DOM anim val wraps our base val too!
DOMSVGPathSegList *animValWrapper =
DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
if (animValWrapper) {
animValWrapper->InternalListWillChangeTo(SVGPathData());
}
}
mBaseVal.Clear();
// Caller notifies
}
nsresult
SVGAnimatedPathSegList::SetAnimValue(const SVGPathData& aNewAnimValue,
nsSVGElement *aElement)
{
// Note that a new animation may totally change the number of items in the
// animVal list, either replacing what was essentially a mirror of the
// baseVal list, or else replacing and overriding an existing animation.
// Unfortunately it is not possible for us to reliably distinguish between
// calls to this method that are setting a new sample for an existing
// animation, and calls that are setting the first sample of an animation
// that will override an existing animation. In the case of DOMSVGPathSegList
// the InternalListWillChangeTo method is not virtually free as it is for the
// other DOM list classes, so this is a shame. We'd quite like to be able to
// skip the call if possible.
// We must send these notifications *before* changing mAnimVal! (See above.)
DOMSVGPathSegList *domWrapper =
DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
if (domWrapper) {
domWrapper->InternalListWillChangeTo(aNewAnimValue);
}
if (!mAnimVal) {
mAnimVal = new SVGPathData();
}
nsresult rv = mAnimVal->CopyFrom(aNewAnimValue);
if (NS_FAILED(rv)) {
// OOM. We clear the animation and, importantly, ClearAnimValue() ensures
// that mAnimVal's DOM wrapper (if any) is kept in sync!
ClearAnimValue(aElement);
}
aElement->DidAnimatePathSegList();
return rv;
}
void
SVGAnimatedPathSegList::ClearAnimValue(nsSVGElement *aElement)
{
// We must send these notifications *before* changing mAnimVal! (See above.)
DOMSVGPathSegList *domWrapper =
DOMSVGPathSegList::GetDOMWrapperIfExists(GetAnimValKey());
if (domWrapper) {
// When all animation ends, animVal simply mirrors baseVal, which may have
// a different number of items to the last active animated value.
//
domWrapper->InternalListWillChangeTo(mBaseVal);
}
mAnimVal = nullptr;
aElement->DidAnimatePathSegList();
}
UniquePtr<nsISMILAttr>
SVGAnimatedPathSegList::ToSMILAttr(nsSVGElement *aElement)
{
return MakeUnique<SMILAnimatedPathSegList>(this, aElement);
}
nsresult
SVGAnimatedPathSegList::
SMILAnimatedPathSegList::ValueFromString(const nsAString& aStr,
const dom::SVGAnimationElement* /*aSrcElement*/,
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(SVGPathSegListSMILType::Singleton());
SVGPathDataAndInfo *list = static_cast<SVGPathDataAndInfo*>(val.mU.mPtr);
nsresult rv = list->SetValueFromString(aStr);
if (NS_SUCCEEDED(rv)) {
list->SetElement(mElement);
aValue = Move(val);
}
aPreventCachingOfSandwich = false;
return rv;
}
nsSMILValue
SVGAnimatedPathSegList::SMILAnimatedPathSegList::GetBaseValue() const
{
// To benefit from Return Value Optimization and avoid copy constructor calls
// due to our use of return-by-value, we must return the exact same object
// from ALL return points. This function must only return THIS variable:
nsSMILValue val;
nsSMILValue tmp(SVGPathSegListSMILType::Singleton());
SVGPathDataAndInfo *list = static_cast<SVGPathDataAndInfo*>(tmp.mU.mPtr);
nsresult rv = list->CopyFrom(mVal->mBaseVal);
if (NS_SUCCEEDED(rv)) {
list->SetElement(mElement);
val = Move(tmp);
}
return val;
}
nsresult
SVGAnimatedPathSegList::SMILAnimatedPathSegList::SetAnimValue(const nsSMILValue& aValue)
{
NS_ASSERTION(aValue.mType == SVGPathSegListSMILType::Singleton(),
"Unexpected type to assign animated value");
if (aValue.mType == SVGPathSegListSMILType::Singleton()) {
mVal->SetAnimValue(*static_cast<SVGPathDataAndInfo*>(aValue.mU.mPtr),
mElement);
}
return NS_OK;
}
void
SVGAnimatedPathSegList::SMILAnimatedPathSegList::ClearAnimValue()
{
if (mVal->mAnimVal) {
mVal->ClearAnimValue(mElement);
}
}
size_t
SVGAnimatedPathSegList::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
{
size_t total = mBaseVal.SizeOfExcludingThis(aMallocSizeOf);
if (mAnimVal) {
mAnimVal->SizeOfIncludingThis(aMallocSizeOf);
}
return total;
}
} // namespace mozilla