The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* 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/. */

 // Main header first:

 #include "nsSVGEffects.h"

 // Keep others in (case-insensitive) order:

 #include "nsCSSFrameConstructor.h"

 #include "nsISupportsImpl.h"

 #include "nsSVGClipPathFrame.h"

 #include "nsSVGPaintServerFrame.h"

 #include "nsSVGPathGeometryElement.h"

 #include "nsSVGFilterFrame.h"

 #include "nsSVGMaskFrame.h"

 #include "nsIReflowCallback.h"

 #include "RestyleManager.h"

 using namespace mozilla;

 using namespace mozilla::dom;

 // nsSVGRenderingObserver impl

 NS_IMPL_ISUPPORTS(nsSVGRenderingObserver, nsIMutationObserver)

 void

 nsSVGRenderingObserver::StartListening()

 {

   Element* target = GetTarget();

   if (target) {

     target->AddMutationObserver(this);

   }

 }

 void

 nsSVGRenderingObserver::StopListening()

 {

   Element* target = GetTarget();

   if (target) {

     target->RemoveMutationObserver(this);

     if (mInObserverList) {

       nsSVGEffects::RemoveRenderingObserver(target, this);

       mInObserverList = false;

     }

   }

   NS_ASSERTION(!mInObserverList, "still in an observer list?");

 }

 /**

  * Note that in the current setup there are two separate observer lists.

  *

  * In nsSVGIDRenderingObserver's ctor, the new object adds itself to the

  * mutation observer list maintained by the referenced element. In this way the

  * nsSVGIDRenderingObserver is notified if there are any attribute or content

  * tree changes to the element or any of its *descendants*.

  *

  * In nsSVGIDRenderingObserver::GetReferencedElement() the

  * nsSVGIDRenderingObserver object also adds itself to an

  * nsSVGRenderingObserverList object belonging to the referenced

  * element.

  *

  * XXX: it would be nice to have a clear and concise executive summary of the

  * benefits/necessity of maintaining a second observer list.

  */

 nsSVGIDRenderingObserver::nsSVGIDRenderingObserver(nsIURI *aURI,

                                                    nsIFrame *aFrame,

                                                    bool aReferenceImage)

   : mElement(MOZ_THIS_IN_INITIALIZER_LIST()), mFrame(aFrame),

     mFramePresShell(aFrame->PresContext()->PresShell())

 {

   // Start watching the target element

   mElement.Reset(aFrame->GetContent(), aURI, true, aReferenceImage);

   StartListening();

 }

 nsSVGIDRenderingObserver::~nsSVGIDRenderingObserver()

 {

   StopListening();

 }

 static nsSVGRenderingObserverList *

 GetObserverList(Element *aElement)

 {

   return static_cast<nsSVGRenderingObserverList*>

     (aElement->GetProperty(nsGkAtoms::renderingobserverlist));

 }

 Element*

 nsSVGRenderingObserver::GetReferencedElement()

 {

   Element* target = GetTarget();

 #ifdef DEBUG

   if (target) {

     nsSVGRenderingObserverList *observerList = GetObserverList(target);

     bool inObserverList = observerList && observerList->Contains(this);

     NS_ASSERTION(inObserverList == mInObserverList, "failed to track whether we're in our referenced element's observer list!");

   } else {

     NS_ASSERTION(!mInObserverList, "In whose observer list are we, then?");

   }

 #endif

   if (target && !mInObserverList) {

     nsSVGEffects::AddRenderingObserver(target, this);

     mInObserverList = true;

   }

   return target;

 }

 nsIFrame*

 nsSVGRenderingObserver::GetReferencedFrame()

 {

   Element* referencedElement = GetReferencedElement();

   return referencedElement ? referencedElement->GetPrimaryFrame() : nullptr;

 }

 nsIFrame*

 nsSVGRenderingObserver::GetReferencedFrame(nsIAtom* aFrameType, bool* aOK)

 {

   nsIFrame* frame = GetReferencedFrame();

   if (frame) {

     if (frame->GetType() == aFrameType)

       return frame;

     if (aOK) {

       *aOK = false;

     }

   }

   return nullptr;

 }

 void

 nsSVGIDRenderingObserver::DoUpdate()

 {

   if (mFramePresShell->IsDestroying()) {

     // mFrame is no longer valid. Bail out.

     mFrame = nullptr;

     return;

   }

   if (mElement.get() && mInObserverList) {

     nsSVGEffects::RemoveRenderingObserver(mElement.get(), this);

     mInObserverList = false;

   }

   if (mFrame && mFrame->IsFrameOfType(nsIFrame::eSVG)) {

     // Changes should propagate out to things that might be observing

     // the referencing frame or its ancestors.

     nsSVGEffects::InvalidateRenderingObservers(mFrame);

   }

 }

 void

 nsSVGRenderingObserver::InvalidateViaReferencedElement()

 {

   mInObserverList = false;

   DoUpdate();

 }

 void

 nsSVGRenderingObserver::NotifyEvictedFromRenderingObserverList()

 {

   mInObserverList = false; // We've been removed from rendering-obs. list.

   StopListening();            // Remove ourselves from mutation-obs. list.

 }

 void

 nsSVGRenderingObserver::AttributeChanged(nsIDocument* aDocument,

                                          dom::Element* aElement,

                                          int32_t aNameSpaceID,

                                          nsIAtom* aAttribute,

                                          int32_t aModType)

 {

   // An attribute belonging to the element that we are observing *or one of its

   // descendants* has changed.

   //

   // In the case of observing a gradient element, say, we want to know if any

   // of its 'stop' element children change, but we don't actually want to do

   // anything for changes to SMIL element children, for example. Maybe it's not

   // worth having logic to optimize for that, but in most cases it could be a

   // small check?

   //

   // XXXjwatt: do we really want to blindly break the link between our

   // observers and ourselves for all attribute changes? For non-ID changes

   // surely that is unnecessary.

   DoUpdate();

 }

 void

 nsSVGRenderingObserver::ContentAppended(nsIDocument *aDocument,

                                         nsIContent *aContainer,

                                         nsIContent *aFirstNewContent,

                                         int32_t /* unused */)

 {

   DoUpdate();

 }

 void

 nsSVGRenderingObserver::ContentInserted(nsIDocument *aDocument,

                                         nsIContent *aContainer,

                                         nsIContent *aChild,

                                         int32_t /* unused */)

 {

   DoUpdate();

 }

 void

 nsSVGRenderingObserver::ContentRemoved(nsIDocument *aDocument,

                                        nsIContent *aContainer,

                                        nsIContent *aChild,

                                        int32_t aIndexInContainer,

                                        nsIContent *aPreviousSibling)

 {

   DoUpdate();

 }

 NS_IMPL_ISUPPORTS(nsSVGFilterProperty, nsISupports)

 nsSVGFilterProperty::nsSVGFilterProperty(const nsTArray<nsStyleFilter> &aFilters,

                                          nsIFrame *aFilteredFrame) :

   mFilters(aFilters)

 {

   for (uint32_t i = 0; i < mFilters.Length(); i++) {

     if (mFilters[i].GetType() != NS_STYLE_FILTER_URL)

       continue;

     nsSVGFilterReference *reference =

       new nsSVGFilterReference(mFilters[i].GetURL(), aFilteredFrame);

     NS_ADDREF(reference);

     mReferences.AppendElement(reference);

   }

 }

 nsSVGFilterProperty::~nsSVGFilterProperty()

 {

   for (uint32_t i = 0; i < mReferences.Length(); i++) {

     NS_RELEASE(mReferences[i]);

   }

 }

 bool

 nsSVGFilterProperty::ReferencesValidResources()

 {

   for (uint32_t i = 0; i < mReferences.Length(); i++) {

     if (!mReferences[i]->ReferencesValidResource())

       return false;

   }

   return true;

 }

 bool

 nsSVGFilterProperty::IsInObserverLists() const

 {

   for (uint32_t i = 0; i < mReferences.Length(); i++) {

     if (!mReferences[i]->IsInObserverList())

       return false;

   }

   return true;

 }

 void

 nsSVGFilterProperty::Invalidate()

 {

   for (uint32_t i = 0; i < mReferences.Length(); i++) {

     mReferences[i]->Invalidate();

   }

 }

 NS_IMPL_ISUPPORTS_INHERITED(nsSVGFilterReference,

                             nsSVGIDRenderingObserver,

                             nsISVGFilterReference);

 nsSVGFilterFrame *

 nsSVGFilterReference::GetFilterFrame()

 {

   return static_cast<nsSVGFilterFrame *>

     (GetReferencedFrame(nsGkAtoms::svgFilterFrame, nullptr));

 }

 static void

 InvalidateAllContinuations(nsIFrame* aFrame)

 {

   for (nsIFrame* f = aFrame; f;

        f = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(f)) {

     f->InvalidateFrame();

   }

 }

 void

 nsSVGFilterReference::DoUpdate()

 {

   nsSVGIDRenderingObserver::DoUpdate();

   if (!mFrame)

     return;

   // Repaint asynchronously in case the filter frame is being torn down

   nsChangeHint changeHint =

     nsChangeHint(nsChangeHint_RepaintFrame);

   // Don't need to request UpdateOverflow if we're being reflowed.

   if (!(mFrame->GetStateBits() & NS_FRAME_IN_REFLOW)) {

     NS_UpdateHint(changeHint, nsChangeHint_UpdateOverflow);

   }

   mFramePresShell->GetPresContext()->RestyleManager()->PostRestyleEvent(

     mFrame->GetContent()->AsElement(), nsRestyleHint(0), changeHint);

 }

 void

 nsSVGMarkerProperty::DoUpdate()

 {

   nsSVGIDRenderingObserver::DoUpdate();

   if (!mFrame)

     return;

   NS_ASSERTION(mFrame->IsFrameOfType(nsIFrame::eSVG), "SVG frame expected");

   // Repaint asynchronously in case the marker frame is being torn down

   nsChangeHint changeHint =

     nsChangeHint(nsChangeHint_RepaintFrame);

   // Don't need to request ReflowFrame if we're being reflowed.

   if (!(mFrame->GetStateBits() & NS_FRAME_IN_REFLOW)) {

     // XXXjwatt: We need to unify SVG into standard reflow so we can just use

     // nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow here.

     nsSVGEffects::InvalidateRenderingObservers(mFrame);

     // XXXSDL KILL THIS!!!

     nsSVGUtils::ScheduleReflowSVG(mFrame);

   }

   mFramePresShell->GetPresContext()->RestyleManager()->PostRestyleEvent(

     mFrame->GetContent()->AsElement(), nsRestyleHint(0), changeHint);

 }

 bool

 nsSVGTextPathProperty::TargetIsValid()

 {

   Element* target = GetTarget();

   return target && target->IsSVG(nsGkAtoms::path);

 }

 void

 nsSVGTextPathProperty::DoUpdate()

 {

   nsSVGIDRenderingObserver::DoUpdate();

   if (!mFrame)

     return;

   NS_ASSERTION(mFrame->IsFrameOfType(nsIFrame::eSVG) || mFrame->IsSVGText(),

                "SVG frame expected");

   // Avoid getting into an infinite loop of reflows if the <textPath> is

   // pointing to one of its ancestors.  TargetIsValid returns true iff

   // the target element is a <path> element, and we would not have this

   // nsSVGTextPathProperty if this <textPath> were a descendant of the

   // target <path>.

   //

   // Note that we still have to post the restyle event when we

   // change from being valid to invalid, so that mPositions on the

   // SVGTextFrame gets updated, skipping the <textPath>, ensuring

   // that nothing gets painted for that element.

   bool nowValid = TargetIsValid();

   if (!mValid && !nowValid) {

     // Just return if we were previously invalid, and are still invalid.

     return;

   }

   mValid = nowValid;

   // Repaint asynchronously in case the path frame is being torn down

   nsChangeHint changeHint =

     nsChangeHint(nsChangeHint_RepaintFrame | nsChangeHint_UpdateTextPath);

   mFramePresShell->GetPresContext()->RestyleManager()->PostRestyleEvent(

     mFrame->GetContent()->AsElement(), nsRestyleHint(0), changeHint);

 }

 void

 nsSVGPaintingProperty::DoUpdate()

 {

   nsSVGIDRenderingObserver::DoUpdate();

   if (!mFrame)

     return;

   if (mFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT) {

     nsSVGEffects::InvalidateRenderingObservers(mFrame);

     mFrame->InvalidateFrameSubtree();

   } else {

     InvalidateAllContinuations(mFrame);

   }

 }

 static nsSVGRenderingObserver *

 CreateMarkerProperty(nsIURI *aURI, nsIFrame *aFrame, bool aReferenceImage)

 { return new nsSVGMarkerProperty(aURI, aFrame, aReferenceImage); }

 static nsSVGRenderingObserver *

 CreateTextPathProperty(nsIURI *aURI, nsIFrame *aFrame, bool aReferenceImage)

 { return new nsSVGTextPathProperty(aURI, aFrame, aReferenceImage); }

 static nsSVGRenderingObserver *

 CreatePaintingProperty(nsIURI *aURI, nsIFrame *aFrame, bool aReferenceImage)

 { return new nsSVGPaintingProperty(aURI, aFrame, aReferenceImage); }

 static nsSVGRenderingObserver *

 GetEffectProperty(nsIURI *aURI, nsIFrame *aFrame,

                   const FramePropertyDescriptor *aProperty,

                   nsSVGRenderingObserver * (* aCreate)(nsIURI *, nsIFrame *, bool))

 {

   if (!aURI)

     return nullptr;

   FrameProperties props = aFrame->Properties();

   nsSVGRenderingObserver *prop =

     static_cast<nsSVGRenderingObserver*>(props.Get(aProperty));

   if (prop)

     return prop;

   prop = aCreate(aURI, aFrame, false);

   if (!prop)

     return nullptr;

   NS_ADDREF(prop);

   props.Set(aProperty, static_cast<nsISupports*>(prop));

   return prop;

 }

 static nsSVGFilterProperty*

 GetOrCreateFilterProperty(nsIFrame *aFrame)

 {

   const nsStyleSVGReset* style = aFrame->StyleSVGReset();

   if (!style->HasFilters())

     return nullptr;

   FrameProperties props = aFrame->Properties();

   nsSVGFilterProperty *prop =

     static_cast<nsSVGFilterProperty*>(props.Get(nsSVGEffects::FilterProperty()));

   if (prop)

     return prop;

   prop = new nsSVGFilterProperty(style->mFilters, aFrame);

   if (!prop)

     return nullptr;

   NS_ADDREF(prop);

   props.Set(nsSVGEffects::FilterProperty(), static_cast<nsISupports*>(prop));

   return prop;

 }

 nsSVGMarkerProperty *

 nsSVGEffects::GetMarkerProperty(nsIURI *aURI, nsIFrame *aFrame,

                                 const FramePropertyDescriptor *aProp)

 {

   NS_ABORT_IF_FALSE(aFrame->GetType() == nsGkAtoms::svgPathGeometryFrame &&

                       static_cast<nsSVGPathGeometryElement*>(aFrame->GetContent())->IsMarkable(),

                     "Bad frame");

   return static_cast<nsSVGMarkerProperty*>(

           GetEffectProperty(aURI, aFrame, aProp, CreateMarkerProperty));

 }

 nsSVGTextPathProperty *

 nsSVGEffects::GetTextPathProperty(nsIURI *aURI, nsIFrame *aFrame,

                                   const FramePropertyDescriptor *aProp)

 {

   return static_cast<nsSVGTextPathProperty*>(

           GetEffectProperty(aURI, aFrame, aProp, CreateTextPathProperty));

 }

 nsSVGPaintingProperty *

 nsSVGEffects::GetPaintingProperty(nsIURI *aURI, nsIFrame *aFrame,

                                   const FramePropertyDescriptor *aProp)

 {

   return static_cast<nsSVGPaintingProperty*>(

           GetEffectProperty(aURI, aFrame, aProp, CreatePaintingProperty));

 }

 static nsSVGRenderingObserver *

 GetEffectPropertyForURI(nsIURI *aURI, nsIFrame *aFrame,

                         const FramePropertyDescriptor *aProperty,

                         nsSVGRenderingObserver * (* aCreate)(nsIURI *, nsIFrame *, bool))

 {

   if (!aURI)

     return nullptr;

   FrameProperties props = aFrame->Properties();

   nsSVGEffects::URIObserverHashtable *hashtable =

     static_cast<nsSVGEffects::URIObserverHashtable*>(props.Get(aProperty));

   if (!hashtable) {

     hashtable = new nsSVGEffects::URIObserverHashtable();

     props.Set(aProperty, hashtable);

   }

   nsSVGRenderingObserver* prop =

     static_cast<nsSVGRenderingObserver*>(hashtable->GetWeak(aURI));

   if (!prop) {

     bool watchImage = aProperty == nsSVGEffects::BackgroundImageProperty();

     prop = aCreate(aURI, aFrame, watchImage);

     hashtable->Put(aURI, prop);

   }

   return prop;

 }

 nsSVGPaintingProperty *

 nsSVGEffects::GetPaintingPropertyForURI(nsIURI *aURI, nsIFrame *aFrame,

                                         const FramePropertyDescriptor *aProp)

 {

   return static_cast<nsSVGPaintingProperty*>(

           GetEffectPropertyForURI(aURI, aFrame, aProp, CreatePaintingProperty));

 }

 nsSVGEffects::EffectProperties

 nsSVGEffects::GetEffectProperties(nsIFrame *aFrame)

 {

   NS_ASSERTION(!aFrame->GetPrevContinuation(), "aFrame should be first continuation");

   EffectProperties result;

   const nsStyleSVGReset *style = aFrame->StyleSVGReset();

   result.mFilter = GetOrCreateFilterProperty(aFrame);

   result.mClipPath =

     GetPaintingProperty(style->mClipPath, aFrame, ClipPathProperty());

   result.mMask =

     GetPaintingProperty(style->mMask, aFrame, MaskProperty());

   return result;

 }

 nsSVGPaintServerFrame *

 nsSVGEffects::GetPaintServer(nsIFrame *aTargetFrame, const nsStyleSVGPaint *aPaint,

                              const FramePropertyDescriptor *aType)

 {

   if (aPaint->mType != eStyleSVGPaintType_Server)

     return nullptr;

   nsIFrame *frame = aTargetFrame->GetContent()->IsNodeOfType(nsINode::eTEXT) ?

                       aTargetFrame->GetParent() : aTargetFrame;

   nsSVGPaintingProperty *property =

     nsSVGEffects::GetPaintingProperty(aPaint->mPaint.mPaintServer, frame, aType);

   if (!property)

     return nullptr;

   nsIFrame *result = property->GetReferencedFrame();

   if (!result)

     return nullptr;

   nsIAtom *type = result->GetType();

   if (type != nsGkAtoms::svgLinearGradientFrame &&

       type != nsGkAtoms::svgRadialGradientFrame &&

       type != nsGkAtoms::svgPatternFrame)

     return nullptr;

   return static_cast<nsSVGPaintServerFrame*>(result);

 }

 nsSVGClipPathFrame *

 nsSVGEffects::EffectProperties::GetClipPathFrame(bool *aOK)

 {

   if (!mClipPath)

     return nullptr;

   nsSVGClipPathFrame *frame = static_cast<nsSVGClipPathFrame *>

     (mClipPath->GetReferencedFrame(nsGkAtoms::svgClipPathFrame, aOK));

   if (frame && aOK && *aOK) {

     *aOK = frame->IsValid();

   }

   return frame;

 }

 nsSVGMaskFrame *

 nsSVGEffects::EffectProperties::GetMaskFrame(bool *aOK)

 {

   if (!mMask)

     return nullptr;

   return static_cast<nsSVGMaskFrame *>

     (mMask->GetReferencedFrame(nsGkAtoms::svgMaskFrame, aOK));

 }

 void

 nsSVGEffects::UpdateEffects(nsIFrame *aFrame)

 {

   NS_ASSERTION(aFrame->GetContent()->IsElement(),

                "aFrame's content should be an element");

   FrameProperties props = aFrame->Properties();

   props.Delete(FilterProperty());

   props.Delete(MaskProperty());

   props.Delete(ClipPathProperty());

   props.Delete(MarkerBeginProperty());

   props.Delete(MarkerMiddleProperty());

   props.Delete(MarkerEndProperty());

   props.Delete(FillProperty());

   props.Delete(StrokeProperty());

   props.Delete(BackgroundImageProperty());

   // Ensure that the filter is repainted correctly

   // We can't do that in DoUpdate as the referenced frame may not be valid

   GetOrCreateFilterProperty(aFrame);

   if (aFrame->GetType() == nsGkAtoms::svgPathGeometryFrame &&

       static_cast<nsSVGPathGeometryElement*>(aFrame->GetContent())->IsMarkable()) {

     // Set marker properties here to avoid reference loops

     const nsStyleSVG *style = aFrame->StyleSVG();

     GetEffectProperty(style->mMarkerStart, aFrame, MarkerBeginProperty(),

                       CreateMarkerProperty);

     GetEffectProperty(style->mMarkerMid, aFrame, MarkerMiddleProperty(),

                       CreateMarkerProperty);

     GetEffectProperty(style->mMarkerEnd, aFrame, MarkerEndProperty(),

                       CreateMarkerProperty);

   }

 }

 nsSVGFilterProperty *

 nsSVGEffects::GetFilterProperty(nsIFrame *aFrame)

 {

   NS_ASSERTION(!aFrame->GetPrevContinuation(), "aFrame should be first continuation");

   if (!aFrame->StyleSVGReset()->HasFilters())

     return nullptr;

   return static_cast<nsSVGFilterProperty *>

     (aFrame->Properties().Get(FilterProperty()));

 }

 static PLDHashOperator

 GatherEnumerator(nsPtrHashKey<nsSVGRenderingObserver>* aEntry, void* aArg)

 {

   nsTArray<nsSVGRenderingObserver*>* array =

     static_cast<nsTArray<nsSVGRenderingObserver*>*>(aArg);

   array->AppendElement(aEntry->GetKey());

   return PL_DHASH_REMOVE;

 }

 static PLDHashOperator

 GatherEnumeratorForReflow(nsPtrHashKey<nsSVGRenderingObserver>* aEntry, void* aArg)

 {

   if (!aEntry->GetKey()->ObservesReflow()) {

     return PL_DHASH_NEXT;

   }

   nsTArray<nsSVGRenderingObserver*>* array =

     static_cast<nsTArray<nsSVGRenderingObserver*>*>(aArg);

   array->AppendElement(aEntry->GetKey());

   return PL_DHASH_REMOVE;

 }

 void

 nsSVGRenderingObserverList::InvalidateAll()

 {

   if (mObservers.Count() == 0)

     return;

   nsAutoTArray<nsSVGRenderingObserver*,10> observers;

   // The PL_DHASH_REMOVE in GatherEnumerator drops all our observers here:

   mObservers.EnumerateEntries(GatherEnumerator, &observers);

   for (uint32_t i = 0; i < observers.Length(); ++i) {

     observers[i]->InvalidateViaReferencedElement();

   }

 }

 void

 nsSVGRenderingObserverList::InvalidateAllForReflow()

 {

   if (mObservers.Count() == 0)

     return;

   nsAutoTArray<nsSVGRenderingObserver*,10> observers;

   // The PL_DHASH_REMOVE in GatherEnumerator drops all our observers here:

   mObservers.EnumerateEntries(GatherEnumeratorForReflow, &observers);

   for (uint32_t i = 0; i < observers.Length(); ++i) {

     observers[i]->InvalidateViaReferencedElement();

   }

 }

 void

 nsSVGRenderingObserverList::RemoveAll()

 {

   nsAutoTArray<nsSVGRenderingObserver*,10> observers;

   // The PL_DHASH_REMOVE in GatherEnumerator drops all our observers here:

   mObservers.EnumerateEntries(GatherEnumerator, &observers);

   // Our list is now cleared.  We need to notify the observers we've removed,

   // so they can update their state & remove themselves as mutation-observers.

   for (uint32_t i = 0; i < observers.Length(); ++i) {

     observers[i]->NotifyEvictedFromRenderingObserverList();

   }

 }

 void

 nsSVGEffects::AddRenderingObserver(Element *aElement, nsSVGRenderingObserver *aObserver)

 {

   nsSVGRenderingObserverList *observerList = GetObserverList(aElement);

   if (!observerList) {

     observerList = new nsSVGRenderingObserverList();

     if (!observerList)

       return;

     aElement->SetProperty(nsGkAtoms::renderingobserverlist, observerList,

                           nsINode::DeleteProperty<nsSVGRenderingObserverList>);

   }

   aElement->SetHasRenderingObservers(true);

   observerList->Add(aObserver);

 }

 void

 nsSVGEffects::RemoveRenderingObserver(Element *aElement, nsSVGRenderingObserver *aObserver)

 {

   nsSVGRenderingObserverList *observerList = GetObserverList(aElement);

   if (observerList) {

     NS_ASSERTION(observerList->Contains(aObserver),

                  "removing observer from an element we're not observing?");

     observerList->Remove(aObserver);

     if (observerList->IsEmpty()) {

       aElement->SetHasRenderingObservers(false);

     }

   }

 }

 void

 nsSVGEffects::RemoveAllRenderingObservers(Element *aElement)

 {

   nsSVGRenderingObserverList *observerList = GetObserverList(aElement);

   if (observerList) {

     observerList->RemoveAll();

     aElement->SetHasRenderingObservers(false);

   }

 }

 void

 nsSVGEffects::InvalidateRenderingObservers(nsIFrame *aFrame)

 {

   NS_ASSERTION(!aFrame->GetPrevContinuation(), "aFrame must be first continuation");

   if (!aFrame->GetContent()->IsElement())

     return;

   nsSVGRenderingObserverList *observerList =

     GetObserverList(aFrame->GetContent()->AsElement());

   if (observerList) {

     observerList->InvalidateAll();

     return;

   }

   // Check ancestor SVG containers. The root frame cannot be of type

   // eSVGContainer so we don't have to check f for null here.

   for (nsIFrame *f = aFrame->GetParent();

        f->IsFrameOfType(nsIFrame::eSVGContainer); f = f->GetParent()) {

     if (f->GetContent()->IsElement()) {

       observerList = GetObserverList(f->GetContent()->AsElement());

       if (observerList) {

         observerList->InvalidateAll();

         return;

       }

     }

   }

 }

 void

 nsSVGEffects::InvalidateDirectRenderingObservers(Element *aElement, uint32_t aFlags /* = 0 */)

 {

   if (aElement->HasRenderingObservers()) {

     nsSVGRenderingObserverList *observerList = GetObserverList(aElement);

     if (observerList) {

       if (aFlags & INVALIDATE_REFLOW) {

         observerList->InvalidateAllForReflow();

       } else {

         observerList->InvalidateAll();

       }

     }

   }

 }

 void

 nsSVGEffects::InvalidateDirectRenderingObservers(nsIFrame *aFrame, uint32_t aFlags /* = 0 */)

 {

   if (aFrame->GetContent() && aFrame->GetContent()->IsElement()) {

     InvalidateDirectRenderingObservers(aFrame->GetContent()->AsElement(), aFlags);

   }

 }