layout/svg/SVGObserverUtils.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 // Main header first:
   8 #include "SVGObserverUtils.h"
   9
  10 // Keep others in (case-insensitive) order:
  11 #include "mozilla/css/ImageLoader.h"
  12 #include "mozilla/dom/CanvasRenderingContext2D.h"
  13 #include "mozilla/dom/ReferrerInfo.h"
  14 #include "mozilla/dom/SVGGeometryElement.h"
  15 #include "mozilla/dom/SVGMPathElement.h"
  16 #include "mozilla/dom/SVGTextPathElement.h"
  17 #include "mozilla/dom/SVGUseElement.h"
  18 #include "mozilla/PresShell.h"
  19 #include "mozilla/RestyleManager.h"
  20 #include "mozilla/SVGClipPathFrame.h"
  21 #include "mozilla/SVGGeometryFrame.h"
  22 #include "mozilla/SVGMaskFrame.h"
  23 #include "mozilla/SVGTextFrame.h"
  24 #include "mozilla/SVGUtils.h"
  25 #include "nsCSSFrameConstructor.h"
  26 #include "nsCycleCollectionParticipant.h"
  27 #include "nsHashKeys.h"
  28 #include "nsIContent.h"
  29 #include "nsIContentInlines.h"
  30 #include "nsInterfaceHashtable.h"
  31 #include "nsIReflowCallback.h"
  32 #include "nsISupportsImpl.h"
  33 #include "nsLayoutUtils.h"
  34 #include "nsNetUtil.h"
  35 #include "nsTHashtable.h"
  36 #include "nsURIHashKey.h"
  37 #include "SVGFilterFrame.h"
  38 #include "SVGMarkerFrame.h"
  39 #include "SVGPaintServerFrame.h"
  40
  41 using namespace mozilla::dom;
  42
  43 namespace mozilla {
  44
  45 bool URLAndReferrerInfo::operator==(const URLAndReferrerInfo& aRHS) const {
  46   bool uriEqual = false, referrerEqual = false;
  47   this->mURI->Equals(aRHS.mURI, &uriEqual);
  48   this->mReferrerInfo->Equals(aRHS.mReferrerInfo, &referrerEqual);
  49
  50   return uriEqual && referrerEqual;
  51 }
  52
  53 class URLAndReferrerInfoHashKey : public PLDHashEntryHdr {
  54  public:
  55   using KeyType = const URLAndReferrerInfo*;
  56   using KeyTypePointer = const URLAndReferrerInfo*;
  57
  58   explicit URLAndReferrerInfoHashKey(const URLAndReferrerInfo* aKey) noexcept
  59       : mKey(aKey) {
  60     MOZ_COUNT_CTOR(URLAndReferrerInfoHashKey);
  61   }
  62   URLAndReferrerInfoHashKey(URLAndReferrerInfoHashKey&& aToMove) noexcept
  63       : PLDHashEntryHdr(std::move(aToMove)), mKey(std::move(aToMove.mKey)) {
  64     MOZ_COUNT_CTOR(URLAndReferrerInfoHashKey);
  65   }
  66   MOZ_COUNTED_DTOR(URLAndReferrerInfoHashKey)
  67
  68   const URLAndReferrerInfo* GetKey() const { return mKey; }
  69
  70   bool KeyEquals(const URLAndReferrerInfo* aKey) const {
  71     if (!mKey) {
  72       return !aKey;
  73     }
  74     return *mKey == *aKey;
  75   }
  76
  77   static const URLAndReferrerInfo* KeyToPointer(
  78       const URLAndReferrerInfo* aKey) {
  79     return aKey;
  80   }
  81
  82   static PLDHashNumber HashKey(const URLAndReferrerInfo* aKey) {
  83     if (!aKey) {
  84       // If the key is null, return hash for empty string.
  85       return HashString(""_ns);
  86     }
  87     nsAutoCString urlSpec, referrerSpec;
  88     // nsURIHashKey ignores GetSpec() failures, so we do too:
  89     Unused << aKey->GetURI()->GetSpec(urlSpec);
  90     return AddToHash(
  91         HashString(urlSpec),
  92         static_cast<ReferrerInfo*>(aKey->GetReferrerInfo())->Hash());
  93   }
  94
  95   enum { ALLOW_MEMMOVE = true };
  96
  97  protected:
  98   RefPtr<const URLAndReferrerInfo> mKey;
  99 };
 100
 101 /**
 102  * Return a baseURL for resolving a local-ref URL.
 103  *
 104  * @param aContent an element which uses a local-ref property. Here are some
 105  *                 examples:
 106  *                   <rect fill=url(#foo)>
 107  *                   <circle clip-path=url(#foo)>
 108  *                   <use xlink:href="#foo">
 109  */
 110 static already_AddRefed<nsIURI> GetBaseURLForLocalRef(nsIContent* content,
 111                                                       nsIURI* aURI) {
 112   MOZ_ASSERT(content);
 113
 114   // Content is in a shadow tree.  If this URL was specified in the subtree
 115   // referenced by the <use>, element, and that subtree came from a separate
 116   // resource document, then we want the fragment-only URL to resolve to an
 117   // element from the resource document.  Otherwise, the URL was specified
 118   // somewhere in the document with the <use> element, and we want the
 119   // fragment-only URL to resolve to an element in that document.
 120   if (SVGUseElement* use = content->GetContainingSVGUseShadowHost()) {
 121     if (nsIURI* originalURI = use->GetSourceDocURI()) {
 122       bool isEqualsExceptRef = false;
 123       aURI->EqualsExceptRef(originalURI, &isEqualsExceptRef);
 124       if (isEqualsExceptRef) {
 125         return do_AddRef(originalURI);
 126       }
 127     }
 128   }
 129
 130   // For a local-reference URL, resolve that fragment against the current
 131   // document that relative URLs are resolved against.
 132   return do_AddRef(content->OwnerDoc()->GetDocumentURI());
 133 }
 134
 135 static already_AddRefed<URLAndReferrerInfo> ResolveURLUsingLocalRef(
 136     nsIFrame* aFrame, const StyleComputedImageUrl& aURL) {
 137   MOZ_ASSERT(aFrame);
 138
 139   nsCOMPtr<nsIURI> uri = aURL.GetURI();
 140
 141   if (aURL.IsLocalRef()) {
 142     uri = GetBaseURLForLocalRef(aFrame->GetContent(), uri);
 143     uri = aURL.ResolveLocalRef(uri);
 144   }
 145
 146   if (!uri) {
 147     return nullptr;
 148   }
 149
 150   return do_AddRef(new URLAndReferrerInfo(uri, aURL.ExtraData()));
 151 }
 152
 153 static already_AddRefed<URLAndReferrerInfo> ResolveURLUsingLocalRef(
 154     nsIContent* aContent, const nsAString& aURL) {
 155   // Like GetBaseURLForLocalRef, we want to resolve the
 156   // URL against any <use> element shadow tree's source document.
 157   //
 158   // Unlike GetBaseURLForLocalRef, we are assuming that the URL was specified
 159   // directly on mFrame's content (because this ResolveURLUsingLocalRef
 160   // overload is used for href="" attributes and not CSS URL values), so there
 161   // is no need to check whether the URL was specified / inherited from
 162   // outside the shadow tree.
 163   nsIURI* base = nullptr;
 164   const Encoding* encoding = nullptr;
 165   if (SVGUseElement* use = aContent->GetContainingSVGUseShadowHost()) {
 166     base = use->GetSourceDocURI();
 167     encoding = use->GetSourceDocCharacterSet();
 168   }
 169
 170   if (!base) {
 171     base = aContent->OwnerDoc()->GetDocumentURI();
 172     encoding = aContent->OwnerDoc()->GetDocumentCharacterSet();
 173   }
 174
 175   nsCOMPtr<nsIURI> uri;
 176   Unused << NS_NewURI(getter_AddRefs(uri), aURL, WrapNotNull(encoding), base);
 177
 178   if (!uri) {
 179     return nullptr;
 180   }
 181
 182   // There's no clear refererer policy spec about non-CSS SVG resource
 183   // references Bug 1415044 to investigate which referrer we should use
 184   nsIReferrerInfo* referrerInfo =
 185       aContent->OwnerDoc()->ReferrerInfoForInternalCSSAndSVGResources();
 186
 187   return do_AddRef(new URLAndReferrerInfo(uri, referrerInfo));
 188 }
 189
 190 class SVGFilterObserverList;
 191
 192 /**
 193  * A class used as a member of the "observer" classes below to help them
 194  * avoid dereferencing their frame during presshell teardown when their frame
 195  * may have been destroyed (leaving their pointer to their frame dangling).
 196  *
 197  * When a presshell is torn down, the properties for each frame may not be
 198  * deleted until after the frames are destroyed.  "Observer" objects (attached
 199  * as frame properties) must therefore check whether the presshell is being
 200  * torn down before using their pointer to their frame.
 201  *
 202  * mFramePresShell may be null, but when mFrame is non-null, mFramePresShell
 203  * is guaranteed to be non-null, too.
 204  */
 205 struct SVGFrameReferenceFromProperty {
 206   explicit SVGFrameReferenceFromProperty(nsIFrame* aFrame)
 207       : mFrame(aFrame), mFramePresShell(aFrame->PresShell()) {}
 208
 209   // Clear our reference to the frame.
 210   void Detach() {
 211     mFrame = nullptr;
 212     mFramePresShell = nullptr;
 213   }
 214
 215   // null if the frame has become invalid
 216   nsIFrame* Get() {
 217     if (mFramePresShell && mFramePresShell->IsDestroying()) {
 218       Detach();  // mFrame is no longer valid.
 219     }
 220     return mFrame;
 221   }
 222
 223  private:
 224   // The frame that our property is attached to (may be null).
 225   nsIFrame* mFrame;
 226   PresShell* mFramePresShell;
 227 };
 228
 229 void SVGRenderingObserver::StartObserving() {
 230   Element* target = GetReferencedElementWithoutObserving();
 231   if (target) {
 232     target->AddMutationObserver(this);
 233   }
 234 }
 235
 236 void SVGRenderingObserver::StopObserving() {
 237   Element* target = GetReferencedElementWithoutObserving();
 238
 239   if (target) {
 240     target->RemoveMutationObserver(this);
 241     if (mInObserverSet) {
 242       SVGObserverUtils::RemoveRenderingObserver(target, this);
 243       mInObserverSet = false;
 244     }
 245   }
 246   NS_ASSERTION(!mInObserverSet, "still in an observer set?");
 247 }
 248
 249 Element* SVGRenderingObserver::GetAndObserveReferencedElement() {
 250 #ifdef DEBUG
 251   DebugObserverSet();
 252 #endif
 253   Element* referencedElement = GetReferencedElementWithoutObserving();
 254   if (referencedElement && !mInObserverSet) {
 255     SVGObserverUtils::AddRenderingObserver(referencedElement, this);
 256     mInObserverSet = true;
 257   }
 258   return referencedElement;
 259 }
 260
 261 nsIFrame* SVGRenderingObserver::GetAndObserveReferencedFrame() {
 262   Element* referencedElement = GetAndObserveReferencedElement();
 263   return referencedElement ? referencedElement->GetPrimaryFrame() : nullptr;
 264 }
 265
 266 nsIFrame* SVGRenderingObserver::GetAndObserveReferencedFrame(
 267     LayoutFrameType aFrameType, bool* aOK) {
 268   nsIFrame* frame = GetAndObserveReferencedFrame();
 269   if (frame) {
 270     if (frame->Type() == aFrameType) {
 271       return frame;
 272     }
 273     if (aOK) {
 274       *aOK = false;
 275     }
 276   }
 277   return nullptr;
 278 }
 279
 280 void SVGRenderingObserver::OnNonDOMMutationRenderingChange() {
 281   OnRenderingChange();
 282 }
 283
 284 void SVGRenderingObserver::NotifyEvictedFromRenderingObserverSet() {
 285   mInObserverSet = false;  // We've been removed from rendering-obs. set.
 286   StopObserving();         // Stop observing mutations too.
 287 }
 288
 289 void SVGRenderingObserver::AttributeChanged(dom::Element* aElement,
 290                                             int32_t aNameSpaceID,
 291                                             nsAtom* aAttribute,
 292                                             int32_t aModType,
 293                                             const nsAttrValue* aOldValue) {
 294   if (aElement->IsInNativeAnonymousSubtree()) {
 295     // Don't observe attribute changes in native-anonymous subtrees like
 296     // scrollbars.
 297     return;
 298   }
 299
 300   // An attribute belonging to the element that we are observing *or one of its
 301   // descendants* has changed.
 302   //
 303   // In the case of observing a gradient element, say, we want to know if any
 304   // of its 'stop' element children change, but we don't actually want to do
 305   // anything for changes to SMIL element children, for example. Maybe it's not
 306   // worth having logic to optimize for that, but in most cases it could be a
 307   // small check?
 308   //
 309   // XXXjwatt: do we really want to blindly break the link between our
 310   // observers and ourselves for all attribute changes? For non-ID changes
 311   // surely that is unnecessary.
 312
 313   OnRenderingChange();
 314 }
 315
 316 void SVGRenderingObserver::ContentAppended(nsIContent* aFirstNewContent) {
 317   OnRenderingChange();
 318 }
 319
 320 void SVGRenderingObserver::ContentInserted(nsIContent* aChild) {
 321   OnRenderingChange();
 322 }
 323
 324 void SVGRenderingObserver::ContentRemoved(nsIContent* aChild,
 325                                           nsIContent* aPreviousSibling) {
 326   OnRenderingChange();
 327 }
 328
 329 /**
 330  * SVG elements reference supporting resources by element ID. We need to
 331  * track when those resources change and when the document changes in ways
 332  * that affect which element is referenced by a given ID (e.g., when
 333  * element IDs change). The code here is responsible for that.
 334  *
 335  * When a frame references a supporting resource, we create a property
 336  * object derived from SVGIDRenderingObserver to manage the relationship. The
 337  * property object is attached to the referencing frame.
 338  */
 339 class SVGIDRenderingObserver : public SVGRenderingObserver {
 340  public:
 341   // Callback for checking if the element being observed is valid for this
 342   // observer. Note that this may be called during construction, before the
 343   // deriving class is fully constructed.
 344   using TargetIsValidCallback = bool (*)(const Element&);
 345   SVGIDRenderingObserver(
 346       URLAndReferrerInfo* aURI, nsIContent* aObservingContent,
 347       bool aReferenceImage,
 348       uint32_t aCallbacks = kAttributeChanged | kContentAppended |
 349                             kContentInserted | kContentRemoved,
 350       TargetIsValidCallback aTargetIsValidCallback = nullptr);
 351
 352   void Traverse(nsCycleCollectionTraversalCallback* aCB);
 353
 354  protected:
 355   virtual ~SVGIDRenderingObserver() {
 356     // This needs to call our GetReferencedElementWithoutObserving override,
 357     // so must be called here rather than in our base class's dtor.
 358     StopObserving();
 359   }
 360
 361   void TargetChanged() {
 362     mTargetIsValid = ([this] {
 363       Element* observed = mObservedElementTracker.get();
 364       if (!observed) {
 365         return false;
 366       }
 367       // If the content is observing an ancestor, then return the target is not
 368       // valid.
 369       //
 370       // TODO(emilio): Should we allow content observing its own descendants?
 371       // That seems potentially-bad as well.
 372       if (observed->OwnerDoc() == mObservingContent->OwnerDoc() &&
 373           nsContentUtils::ContentIsHostIncludingDescendantOf(mObservingContent,
 374                                                              observed)) {
 375         return false;
 376       }
 377       if (mTargetIsValidCallback) {
 378         return mTargetIsValidCallback(*observed);
 379       }
 380       return true;
 381     }());
 382   }
 383
 384   Element* GetReferencedElementWithoutObserving() final {
 385     return mTargetIsValid ? mObservedElementTracker.get() : nullptr;
 386   }
 387
 388   void OnRenderingChange() override;
 389
 390   /**
 391    * Helper that provides a reference to the element with the ID that our
 392    * observer wants to observe, and that will invalidate our observer if the
 393    * element that that ID identifies changes to a different element (or none).
 394    */
 395   class ElementTracker final : public IDTracker {
 396    public:
 397     explicit ElementTracker(SVGIDRenderingObserver* aOwningObserver)
 398         : mOwningObserver(aOwningObserver) {}
 399
 400    protected:
 401     void ElementChanged(Element* aFrom, Element* aTo) override {
 402       // Call OnRenderingChange() before the target changes, so that
 403       // mIsTargetValid reflects the right state.
 404       mOwningObserver->OnRenderingChange();
 405       mOwningObserver->StopObserving();
 406       IDTracker::ElementChanged(aFrom, aTo);
 407       mOwningObserver->TargetChanged();
 408       mOwningObserver->StartObserving();
 409       // And same after the target changes, for the same reason.
 410       mOwningObserver->OnRenderingChange();
 411     }
 412     /**
 413      * Override IsPersistent because we want to keep tracking the element
 414      * for the ID even when it changes.
 415      */
 416     bool IsPersistent() override { return true; }
 417
 418    private:
 419     SVGIDRenderingObserver* mOwningObserver;
 420   };
 421
 422   ElementTracker mObservedElementTracker;
 423   RefPtr<Element> mObservingContent;
 424   bool mTargetIsValid = false;
 425   TargetIsValidCallback mTargetIsValidCallback;
 426 };
 427
 428 /**
 429  * Note that in the current setup there are two separate observer lists.
 430  *
 431  * In SVGIDRenderingObserver's ctor, the new object adds itself to the
 432  * mutation observer list maintained by the referenced element. In this way the
 433  * SVGIDRenderingObserver is notified if there are any attribute or content
 434  * tree changes to the element or any of its *descendants*.
 435  *
 436  * In SVGIDRenderingObserver::GetAndObserveReferencedElement() the
 437  * SVGIDRenderingObserver object also adds itself to an
 438  * SVGRenderingObserverSet object belonging to the referenced
 439  * element.
 440  *
 441  * XXX: it would be nice to have a clear and concise executive summary of the
 442  * benefits/necessity of maintaining a second observer list.
 443  */
 444 SVGIDRenderingObserver::SVGIDRenderingObserver(
 445     URLAndReferrerInfo* aURI, nsIContent* aObservingContent,
 446     bool aReferenceImage, uint32_t aCallbacks,
 447     TargetIsValidCallback aTargetIsValidCallback)
 448     : SVGRenderingObserver(aCallbacks),
 449       mObservedElementTracker(this),
 450       mObservingContent(aObservingContent->AsElement()),
 451       mTargetIsValidCallback(aTargetIsValidCallback) {
 452   // Start watching the target element
 453   nsIURI* uri = nullptr;
 454   nsIReferrerInfo* referrerInfo = nullptr;
 455   if (aURI) {
 456     uri = aURI->GetURI();
 457     referrerInfo = aURI->GetReferrerInfo();
 458   }
 459
 460   mObservedElementTracker.ResetToURIFragmentID(
 461       aObservingContent, uri, referrerInfo, true, aReferenceImage);
 462   TargetChanged();
 463   StartObserving();
 464 }
 465
 466 void SVGIDRenderingObserver::Traverse(nsCycleCollectionTraversalCallback* aCB) {
 467   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*aCB, "mObservingContent");
 468   aCB->NoteXPCOMChild(mObservingContent);
 469   mObservedElementTracker.Traverse(aCB);
 470 }
 471
 472 void SVGIDRenderingObserver::OnRenderingChange() {
 473   if (mObservedElementTracker.get() && mInObserverSet) {
 474     SVGObserverUtils::RemoveRenderingObserver(mObservedElementTracker.get(),
 475                                               this);
 476     mInObserverSet = false;
 477   }
 478 }
 479
 480 class SVGRenderingObserverProperty : public SVGIDRenderingObserver {
 481  public:
 482   NS_DECL_ISUPPORTS
 483
 484   SVGRenderingObserverProperty(
 485       URLAndReferrerInfo* aURI, nsIFrame* aFrame, bool aReferenceImage,
 486       uint32_t aCallbacks = kAttributeChanged | kContentAppended |
 487                             kContentInserted | kContentRemoved,
 488       TargetIsValidCallback aTargetIsValidCallback = nullptr)
 489       : SVGIDRenderingObserver(aURI, aFrame->GetContent(), aReferenceImage,
 490                                aCallbacks, aTargetIsValidCallback),
 491         mFrameReference(aFrame) {}
 492
 493  protected:
 494   virtual ~SVGRenderingObserverProperty() = default;  // non-public
 495
 496   void OnRenderingChange() override;
 497
 498   SVGFrameReferenceFromProperty mFrameReference;
 499 };
 500
 501 NS_IMPL_ISUPPORTS(SVGRenderingObserverProperty, nsIMutationObserver)
 502
 503 void SVGRenderingObserverProperty::OnRenderingChange() {
 504   SVGIDRenderingObserver::OnRenderingChange();
 505
 506   if (!mTargetIsValid) {
 507     return;
 508   }
 509
 510   nsIFrame* frame = mFrameReference.Get();
 511
 512   if (frame && frame->HasAllStateBits(NS_FRAME_SVG_LAYOUT)) {
 513     // We need to notify anything that is observing the referencing frame or
 514     // any of its ancestors that the referencing frame has been invalidated.
 515     // Since walking the parent chain checking for observers is expensive we
 516     // do that using a change hint (multiple change hints of the same type are
 517     // coalesced).
 518     nsLayoutUtils::PostRestyleEvent(frame->GetContent()->AsElement(),
 519                                     RestyleHint{0},
 520                                     nsChangeHint_InvalidateRenderingObservers);
 521   }
 522 }
 523
 524 static bool IsSVGGeometryElement(const Element& aObserved) {
 525   return aObserved.IsSVGGeometryElement();
 526 }
 527
 528 class SVGTextPathObserver final : public SVGRenderingObserverProperty {
 529  public:
 530   SVGTextPathObserver(URLAndReferrerInfo* aURI, nsIFrame* aFrame,
 531                       bool aReferenceImage)
 532       : SVGRenderingObserverProperty(aURI, aFrame, aReferenceImage,
 533                                      kAttributeChanged, IsSVGGeometryElement) {}
 534
 535  protected:
 536   void OnRenderingChange() override;
 537 };
 538
 539 void SVGTextPathObserver::OnRenderingChange() {
 540   SVGRenderingObserverProperty::OnRenderingChange();
 541
 542   if (!mTargetIsValid) {
 543     return;
 544   }
 545
 546   nsIFrame* frame = mFrameReference.Get();
 547   if (!frame) {
 548     return;
 549   }
 550
 551   MOZ_ASSERT(frame->IsSVGFrame() || frame->IsInSVGTextSubtree(),
 552              "SVG frame expected");
 553
 554   MOZ_ASSERT(frame->GetContent()->IsSVGElement(nsGkAtoms::textPath),
 555              "expected frame for a <textPath> element");
 556
 557   auto* text = static_cast<SVGTextFrame*>(
 558       nsLayoutUtils::GetClosestFrameOfType(frame, LayoutFrameType::SVGText));
 559   MOZ_ASSERT(text, "expected to find an ancestor SVGTextFrame");
 560   if (text) {
 561     text->AddStateBits(NS_STATE_SVG_POSITIONING_DIRTY);
 562
 563     if (SVGUtils::AnyOuterSVGIsCallingReflowSVG(text)) {
 564       text->AddStateBits(NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN);
 565       if (text->HasAnyStateBits(NS_FRAME_IS_NONDISPLAY)) {
 566         text->ReflowSVGNonDisplayText();
 567       } else {
 568         text->ReflowSVG();
 569       }
 570     } else {
 571       text->ScheduleReflowSVG();
 572     }
 573   }
 574 }
 575
 576 class SVGMPathObserver final : public SVGIDRenderingObserver {
 577  public:
 578   NS_DECL_ISUPPORTS
 579
 580   SVGMPathObserver(URLAndReferrerInfo* aURI, SVGMPathElement* aElement)
 581       : SVGIDRenderingObserver(aURI, aElement, /* aReferenceImage = */ false,
 582                                kAttributeChanged, IsSVGGeometryElement) {}
 583
 584  protected:
 585   virtual ~SVGMPathObserver() = default;  // non-public
 586
 587   void OnRenderingChange() override;
 588 };
 589
 590 NS_IMPL_ISUPPORTS(SVGMPathObserver, nsIMutationObserver)
 591
 592 void SVGMPathObserver::OnRenderingChange() {
 593   SVGIDRenderingObserver::OnRenderingChange();
 594
 595   if (!mTargetIsValid) {
 596     return;
 597   }
 598
 599   auto* element = static_cast<SVGMPathElement*>(mObservingContent.get());
 600   element->NotifyParentOfMpathChange();
 601 }
 602
 603 class SVGMarkerObserver final : public SVGRenderingObserverProperty {
 604  public:
 605   SVGMarkerObserver(URLAndReferrerInfo* aURI, nsIFrame* aFrame,
 606                     bool aReferenceImage)
 607       : SVGRenderingObserverProperty(aURI, aFrame, aReferenceImage,
 608                                      kAttributeChanged | kContentAppended |
 609                                          kContentInserted | kContentRemoved) {}
 610
 611  protected:
 612   void OnRenderingChange() override;
 613 };
 614
 615 void SVGMarkerObserver::OnRenderingChange() {
 616   SVGRenderingObserverProperty::OnRenderingChange();
 617
 618   nsIFrame* frame = mFrameReference.Get();
 619   if (!frame) {
 620     return;
 621   }
 622
 623   MOZ_ASSERT(frame->IsSVGFrame(), "SVG frame expected");
 624
 625   // Don't need to request ReflowFrame if we're being reflowed.
 626   // Because mRect for SVG frames includes the bounds of any markers
 627   // (see the comment for nsIFrame::GetRect), the referencing frame must be
 628   // reflowed for any marker changes.
 629   if (!frame->HasAnyStateBits(NS_FRAME_IN_REFLOW)) {
 630     // XXXjwatt: We need to unify SVG into standard reflow so we can just use
 631     // nsChangeHint_NeedReflow | nsChangeHint_NeedDirtyReflow here.
 632     // XXXSDL KILL THIS!!!
 633     SVGUtils::ScheduleReflowSVG(frame);
 634   }
 635   frame->PresContext()->RestyleManager()->PostRestyleEvent(
 636       frame->GetContent()->AsElement(), RestyleHint{0},
 637       nsChangeHint_RepaintFrame);
 638 }
 639
 640 class SVGPaintingProperty : public SVGRenderingObserverProperty {
 641  public:
 642   SVGPaintingProperty(URLAndReferrerInfo* aURI, nsIFrame* aFrame,
 643                       bool aReferenceImage)
 644       : SVGRenderingObserverProperty(aURI, aFrame, aReferenceImage) {}
 645
 646  protected:
 647   void OnRenderingChange() override;
 648 };
 649
 650 void SVGPaintingProperty::OnRenderingChange() {
 651   SVGRenderingObserverProperty::OnRenderingChange();
 652
 653   nsIFrame* frame = mFrameReference.Get();
 654   if (!frame) {
 655     return;
 656   }
 657
 658   if (frame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
 659     frame->InvalidateFrameSubtree();
 660   } else {
 661     for (nsIFrame* f = frame; f;
 662          f = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(f)) {
 663       f->InvalidateFrame();
 664     }
 665   }
 666 }
 667
 668 // Observer for -moz-element(#element). Note that the observed element does not
 669 // have to be an SVG element.
 670 class SVGMozElementObserver final : public SVGPaintingProperty {
 671  public:
 672   SVGMozElementObserver(URLAndReferrerInfo* aURI, nsIFrame* aFrame)
 673       : SVGPaintingProperty(aURI, aFrame, /* aReferenceImage = */ true) {}
 674
 675   // We only return true here because GetAndObserveBackgroundImage uses us
 676   // to implement observing of arbitrary elements (including HTML elements)
 677   // that may require us to repaint if the referenced element is reflowed.
 678   // Bug 1496065 has been filed to remove that support though.
 679   bool ObservesReflow() override { return true; }
 680 };
 681
 682 /**
 683  * For content with `background-clip: text`.
 684  *
 685  * This observer is unusual in that the observing frame and observed frame are
 686  * the same frame.  This is because the observing frame is observing for reflow
 687  * of its descendant text nodes, since such reflows may not result in the
 688  * frame's nsDisplayBackground changing.  In other words, Display List Based
 689  * Invalidation may not invalidate the frame's background, so we need this
 690  * observer to make sure that happens.
 691  *
 692  * XXX: It's questionable whether we should even be [ab]using the SVG observer
 693  * mechanism for `background-clip:text`.  Since we know that the observed frame
 694  * is the frame we need to invalidate, we could just check the computed style
 695  * in the (one) place where we pass INVALIDATE_REFLOW and invalidate there...
 696  */
 697 class BackgroundClipRenderingObserver : public SVGRenderingObserver {
 698  public:
 699   explicit BackgroundClipRenderingObserver(nsIFrame* aFrame) : mFrame(aFrame) {}
 700
 701   NS_DECL_ISUPPORTS
 702
 703  private:
 704   // We do not call StopObserving() since the observing and observed element
 705   // are the same element (and because we could crash - see bug 1556441).
 706   virtual ~BackgroundClipRenderingObserver() = default;
 707
 708   Element* GetReferencedElementWithoutObserving() final {
 709     return mFrame->GetContent()->AsElement();
 710   }
 711
 712   void OnRenderingChange() final;
 713
 714   /**
 715    * Observing for mutations is not enough.  A new font loading and applying
 716    * to the text content could cause it to reflow, and we need to invalidate
 717    * for that.
 718    */
 719   bool ObservesReflow() final { return true; }
 720
 721   // The observer and observee!
 722   nsIFrame* mFrame;
 723 };
 724
 725 NS_IMPL_ISUPPORTS(BackgroundClipRenderingObserver, nsIMutationObserver)
 726
 727 void BackgroundClipRenderingObserver::OnRenderingChange() {
 728   for (nsIFrame* f = mFrame; f;
 729        f = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(f)) {
 730     f->InvalidateFrame();
 731   }
 732 }
 733
 734 static bool IsSVGFilterElement(const Element& aObserved) {
 735   return aObserved.IsSVGElement(nsGkAtoms::filter);
 736 }
 737
 738 /**
 739  * In a filter chain, there can be multiple SVG reference filters.
 740  * e.g. filter: url(#svg-filter-1) blur(10px) url(#svg-filter-2);
 741  *
 742  * This class keeps track of one SVG reference filter in a filter chain.
 743  * e.g. url(#svg-filter-1)
 744  *
 745  * It fires invalidations when the SVG filter element's id changes or when
 746  * the SVG filter element's content changes.
 747  *
 748  * The SVGFilterObserverList class manages a list of SVGFilterObservers.
 749  */
 750 class SVGFilterObserver final : public SVGIDRenderingObserver {
 751  public:
 752   SVGFilterObserver(URLAndReferrerInfo* aURI, nsIContent* aObservingContent,
 753                     SVGFilterObserverList* aFilterChainObserver)
 754       : SVGIDRenderingObserver(aURI, aObservingContent, false,
 755                                kAttributeChanged | kContentAppended |
 756                                    kContentInserted | kContentRemoved,
 757                                IsSVGFilterElement),
 758         mFilterObserverList(aFilterChainObserver) {}
 759
 760   void DetachFromChainObserver() { mFilterObserverList = nullptr; }
 761
 762   /**
 763    * @return the filter frame, or null if there is no filter frame
 764    */
 765   SVGFilterFrame* GetAndObserveFilterFrame();
 766
 767   // nsISupports
 768   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 769   NS_DECL_CYCLE_COLLECTION_CLASS(SVGFilterObserver)
 770
 771   // SVGIDRenderingObserver
 772   void OnRenderingChange() override;
 773
 774  protected:
 775   virtual ~SVGFilterObserver() = default;  // non-public
 776
 777   SVGFilterObserverList* mFilterObserverList;
 778 };
 779
 780 NS_IMPL_CYCLE_COLLECTING_ADDREF(SVGFilterObserver)
 781 NS_IMPL_CYCLE_COLLECTING_RELEASE(SVGFilterObserver)
 782
 783 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SVGFilterObserver)
 784   NS_INTERFACE_MAP_ENTRY(nsISupports)
 785   NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
 786 NS_INTERFACE_MAP_END
 787
 788 NS_IMPL_CYCLE_COLLECTION_CLASS(SVGFilterObserver)
 789
 790 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(SVGFilterObserver)
 791   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservedElementTracker)
 792   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservingContent)
 793 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 794
 795 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SVGFilterObserver)
 796   tmp->StopObserving();
 797   NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservedElementTracker);
 798   NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservingContent)
 799 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 800
 801 SVGFilterFrame* SVGFilterObserver::GetAndObserveFilterFrame() {
 802   return static_cast<SVGFilterFrame*>(
 803       GetAndObserveReferencedFrame(LayoutFrameType::SVGFilter, nullptr));
 804 }
 805
 806 /**
 807  * This class manages a list of SVGFilterObservers, which correspond to
 808  * reference to SVG filters in a list of filters in a given 'filter' property.
 809  * e.g. filter: url(#svg-filter-1) blur(10px) url(#svg-filter-2);
 810  *
 811  * In the above example, the SVGFilterObserverList will manage two
 812  * SVGFilterObservers, one for each of the references to SVG filters.  CSS
 813  * filters like "blur(10px)" don't reference filter elements, so they don't
 814  * need an SVGFilterObserver.  The style system invalidates changes to CSS
 815  * filters.
 816  *
 817  * FIXME(emilio): Why do we need this as opposed to the individual observers we
 818  * create in the constructor?
 819  */
 820 class SVGFilterObserverList : public nsISupports {
 821  public:
 822   SVGFilterObserverList(Span<const StyleFilter> aFilters,
 823                         nsIContent* aFilteredElement,
 824                         nsIFrame* aFilteredFrame = nullptr);
 825
 826   const nsTArray<RefPtr<SVGFilterObserver>>& GetObservers() const {
 827     return mObservers;
 828   }
 829
 830   // nsISupports
 831   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 832   NS_DECL_CYCLE_COLLECTION_CLASS(SVGFilterObserverList)
 833
 834   virtual void OnRenderingChange() = 0;
 835
 836  protected:
 837   virtual ~SVGFilterObserverList();
 838
 839   void DetachObservers() {
 840     for (auto& observer : mObservers) {
 841       observer->DetachFromChainObserver();
 842     }
 843   }
 844
 845   nsTArray<RefPtr<SVGFilterObserver>> mObservers;
 846 };
 847
 848 void SVGFilterObserver::OnRenderingChange() {
 849   SVGIDRenderingObserver::OnRenderingChange();
 850
 851   if (mFilterObserverList) {
 852     mFilterObserverList->OnRenderingChange();
 853   }
 854
 855   if (!mTargetIsValid) {
 856     return;
 857   }
 858
 859   nsIFrame* frame = mObservingContent->GetPrimaryFrame();
 860   if (!frame) {
 861     return;
 862   }
 863
 864   // Repaint asynchronously in case the filter frame is being torn down
 865   nsChangeHint changeHint = nsChangeHint(nsChangeHint_RepaintFrame);
 866
 867   // Since we don't call SVGRenderingObserverProperty::
 868   // OnRenderingChange, we have to add this bit ourselves.
 869   if (frame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) {
 870     // Changes should propagate out to things that might be observing
 871     // the referencing frame or its ancestors.
 872     changeHint |= nsChangeHint_InvalidateRenderingObservers;
 873   }
 874
 875   // Don't need to request UpdateOverflow if we're being reflowed.
 876   if (!frame->HasAnyStateBits(NS_FRAME_IN_REFLOW)) {
 877     changeHint |= nsChangeHint_UpdateOverflow;
 878   }
 879   frame->PresContext()->RestyleManager()->PostRestyleEvent(
 880       mObservingContent, RestyleHint{0}, changeHint);
 881 }
 882
 883 NS_IMPL_CYCLE_COLLECTING_ADDREF(SVGFilterObserverList)
 884 NS_IMPL_CYCLE_COLLECTING_RELEASE(SVGFilterObserverList)
 885
 886 NS_IMPL_CYCLE_COLLECTION_CLASS(SVGFilterObserverList)
 887
 888 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(SVGFilterObserverList)
 889   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservers)
 890 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 891
 892 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SVGFilterObserverList)
 893   tmp->DetachObservers();
 894   NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservers);
 895 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 896
 897 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(SVGFilterObserverList)
 898   NS_INTERFACE_MAP_ENTRY(nsISupports)
 899 NS_INTERFACE_MAP_END
 900
 901 SVGFilterObserverList::SVGFilterObserverList(Span<const StyleFilter> aFilters,
 902                                              nsIContent* aFilteredElement,
 903                                              nsIFrame* aFilteredFrame) {
 904   for (const auto& filter : aFilters) {
 905     if (!filter.IsUrl()) {
 906       continue;
 907     }
 908
 909     const auto& url = filter.AsUrl();
 910
 911     // aFilteredFrame can be null if this filter belongs to a
 912     // CanvasRenderingContext2D.
 913     RefPtr<URLAndReferrerInfo> filterURL;
 914     if (aFilteredFrame) {
 915       filterURL = ResolveURLUsingLocalRef(aFilteredFrame, url);
 916     } else {
 917       nsCOMPtr<nsIURI> resolvedURI = url.ResolveLocalRef(aFilteredElement);
 918       if (resolvedURI) {
 919         filterURL = new URLAndReferrerInfo(resolvedURI, url.ExtraData());
 920       }
 921     }
 922
 923     RefPtr<SVGFilterObserver> observer =
 924         new SVGFilterObserver(filterURL, aFilteredElement, this);
 925     mObservers.AppendElement(observer);
 926   }
 927 }
 928
 929 SVGFilterObserverList::~SVGFilterObserverList() { DetachObservers(); }
 930
 931 class SVGFilterObserverListForCSSProp final : public SVGFilterObserverList {
 932  public:
 933   SVGFilterObserverListForCSSProp(Span<const StyleFilter> aFilters,
 934                                   nsIFrame* aFilteredFrame)
 935       : SVGFilterObserverList(aFilters, aFilteredFrame->GetContent(),
 936                               aFilteredFrame) {}
 937
 938  protected:
 939   void OnRenderingChange() override;
 940   bool mInvalidating = false;
 941 };
 942
 943 void SVGFilterObserverListForCSSProp::OnRenderingChange() {
 944   if (mInvalidating) {
 945     return;
 946   }
 947   AutoRestore<bool> guard(mInvalidating);
 948   mInvalidating = true;
 949   for (auto& observer : mObservers) {
 950     observer->OnRenderingChange();
 951   }
 952 }
 953
 954 class SVGFilterObserverListForCanvasContext final
 955     : public SVGFilterObserverList {
 956  public:
 957   SVGFilterObserverListForCanvasContext(CanvasRenderingContext2D* aContext,
 958                                         Element* aCanvasElement,
 959                                         Span<const StyleFilter> aFilters)
 960       : SVGFilterObserverList(aFilters, aCanvasElement), mContext(aContext) {}
 961
 962   void OnRenderingChange() override;
 963   void DetachFromContext() { mContext = nullptr; }
 964
 965  private:
 966   CanvasRenderingContext2D* mContext;
 967 };
 968
 969 void SVGFilterObserverListForCanvasContext::OnRenderingChange() {
 970   if (!mContext) {
 971     NS_WARNING(
 972         "GFX: This should never be called without a context, except during "
 973         "cycle collection (when DetachFromContext has been called)");
 974     return;
 975   }
 976   // Refresh the cached FilterDescription in mContext->CurrentState().filter.
 977   // If this filter is not at the top of the state stack, we'll refresh the
 978   // wrong filter, but that's ok, because we'll refresh the right filter
 979   // when we pop the state stack in CanvasRenderingContext2D::Restore().
 980   //
 981   // We don't need to flush, we're called by layout.
 982   RefPtr<CanvasRenderingContext2D> kungFuDeathGrip(mContext);
 983   kungFuDeathGrip->UpdateFilter(/* aFlushIfNeeded = */ false);
 984 }
 985
 986 class SVGMaskObserverList final : public nsISupports {
 987  public:
 988   explicit SVGMaskObserverList(nsIFrame* aFrame);
 989
 990   // nsISupports
 991   NS_DECL_ISUPPORTS
 992
 993   const nsTArray<RefPtr<SVGPaintingProperty>>& GetObservers() const {
 994     return mProperties;
 995   }
 996
 997   void ResolveImage(uint32_t aIndex);
 998
 999  private:
1000   virtual ~SVGMaskObserverList() = default;  // non-public
1001   nsTArray<RefPtr<SVGPaintingProperty>> mProperties;
1002   nsIFrame* mFrame;
1003 };
1004
1005 NS_IMPL_ISUPPORTS(SVGMaskObserverList, nsISupports)
1006
1007 SVGMaskObserverList::SVGMaskObserverList(nsIFrame* aFrame) : mFrame(aFrame) {
1008   const nsStyleSVGReset* svgReset = aFrame->StyleSVGReset();
1009
1010   for (uint32_t i = 0; i < svgReset->mMask.mImageCount; i++) {
1011     const StyleComputedImageUrl* data =
1012         svgReset->mMask.mLayers[i].mImage.GetImageRequestURLValue();
1013     RefPtr<URLAndReferrerInfo> maskUri;
1014     if (data) {
1015       maskUri = ResolveURLUsingLocalRef(aFrame, *data);
1016     }
1017
1018     bool hasRef = false;
1019     if (maskUri) {
1020       maskUri->GetURI()->GetHasRef(&hasRef);
1021     }
1022
1023     // Accrording to maskUri, SVGPaintingProperty's ctor may trigger an
1024     // external SVG resource download, so we should pass maskUri in only if
1025     // maskUri has a chance pointing to an SVG mask resource.
1026     //
1027     // And, an URL may refer to an SVG mask resource if it consists of
1028     // a fragment.
1029     SVGPaintingProperty* prop = new SVGPaintingProperty(
1030         hasRef ? maskUri.get() : nullptr, aFrame, false);
1031     mProperties.AppendElement(prop);
1032   }
1033 }
1034
1035 void SVGMaskObserverList::ResolveImage(uint32_t aIndex) {
1036   const nsStyleSVGReset* svgReset = mFrame->StyleSVGReset();
1037   MOZ_ASSERT(aIndex < svgReset->mMask.mImageCount);
1038
1039   const auto& image = svgReset->mMask.mLayers[aIndex].mImage;
1040   if (image.IsResolved()) {
1041     return;
1042   }
1043   MOZ_ASSERT(image.IsImageRequestType());
1044   Document* doc = mFrame->PresContext()->Document();
1045   const_cast<StyleImage&>(image).ResolveImage(*doc, nullptr);
1046   if (imgRequestProxy* req = image.GetImageRequest()) {
1047     // FIXME(emilio): What disassociates this request?
1048     doc->StyleImageLoader()->AssociateRequestToFrame(req, mFrame);
1049   }
1050 }
1051
1052 /**
1053  * Used for gradient-to-gradient, pattern-to-pattern and filter-to-filter
1054  * references to "template" elements (specified via the 'href' attributes).
1055  */
1056 class SVGTemplateElementObserver : public SVGIDRenderingObserver {
1057  public:
1058   NS_DECL_ISUPPORTS
1059
1060   SVGTemplateElementObserver(URLAndReferrerInfo* aURI, nsIFrame* aFrame,
1061                              bool aReferenceImage)
1062       : SVGIDRenderingObserver(aURI, aFrame->GetContent(), aReferenceImage,
1063                                kAttributeChanged | kContentAppended |
1064                                    kContentInserted | kContentRemoved),
1065         mFrameReference(aFrame) {}
1066
1067  protected:
1068   virtual ~SVGTemplateElementObserver() = default;  // non-public
1069
1070   void OnRenderingChange() override;
1071
1072   SVGFrameReferenceFromProperty mFrameReference;
1073 };
1074
1075 NS_IMPL_ISUPPORTS(SVGTemplateElementObserver, nsIMutationObserver)
1076
1077 void SVGTemplateElementObserver::OnRenderingChange() {
1078   SVGIDRenderingObserver::OnRenderingChange();
1079
1080   if (nsIFrame* frame = mFrameReference.Get()) {
1081     SVGObserverUtils::InvalidateRenderingObservers(frame);
1082   }
1083 }
1084
1085 /**
1086  * An instance of this class is stored on an observed frame (as a frame
1087  * property) whenever the frame has active rendering observers.  It is used to
1088  * store pointers to the SVGRenderingObserver instances belonging to any
1089  * observing frames, allowing invalidations from the observed frame to be sent
1090  * to all observing frames.
1091  *
1092  * SVGRenderingObserver instances that are added are not strongly referenced,
1093  * so they must remove themselves before they die.
1094  *
1095  * This class is "single-shot", which is to say that when something about the
1096  * observed element changes, InvalidateAll() clears our hashtable of
1097  * SVGRenderingObservers.  SVGRenderingObserver objects will be added back
1098  * again if/when the observing frame looks up our observed frame to use it.
1099  *
1100  * XXXjwatt: is this the best thing to do nowadays?  Back when that mechanism
1101  * landed in bug 330498 we had two pass, recursive invalidation up the frame
1102  * tree, and I think reference loops were a problem.  Nowadays maybe a flag
1103  * on the SVGRenderingObserver objects to coalesce invalidations may work
1104  * better?
1105  *
1106  * InvalidateAll must be called before this object is destroyed, i.e.
1107  * before the referenced frame is destroyed. This should normally happen
1108  * via SVGContainerFrame::RemoveFrame, since only frames in the frame
1109  * tree should be referenced.
1110  */
1111 class SVGRenderingObserverSet {
1112  public:
1113   SVGRenderingObserverSet() : mObservers(4) {
1114     MOZ_COUNT_CTOR(SVGRenderingObserverSet);
1115   }
1116
1117   ~SVGRenderingObserverSet() { MOZ_COUNT_DTOR(SVGRenderingObserverSet); }
1118
1119   void Add(SVGRenderingObserver* aObserver) { mObservers.Insert(aObserver); }
1120   void Remove(SVGRenderingObserver* aObserver) { mObservers.Remove(aObserver); }
1121 #ifdef DEBUG
1122   bool Contains(SVGRenderingObserver* aObserver) {
1123     return mObservers.Contains(aObserver);
1124   }
1125 #endif
1126   bool IsEmpty() { return mObservers.IsEmpty(); }
1127
1128   /**
1129    * Drop all our observers, and notify them that we have changed and dropped
1130    * our reference to them.
1131    */
1132   void InvalidateAll();
1133
1134   /**
1135    * Drop all observers that observe reflow, and notify them that we have
1136    * changed and dropped our reference to them.
1137    */
1138   void InvalidateAllForReflow();
1139
1140   /**
1141    * Drop all our observers, and notify them that we have dropped our reference
1142    * to them.
1143    */
1144   void RemoveAll();
1145
1146  private:
1147   nsTHashSet<SVGRenderingObserver*> mObservers;
1148 };
1149
1150 void SVGRenderingObserverSet::InvalidateAll() {
1151   if (mObservers.IsEmpty()) {
1152     return;
1153   }
1154
1155   const auto observers = std::move(mObservers);
1156
1157   // We've moved all the observers from mObservers, effectively
1158   // evicting them so we need to notify all observers of eviction
1159   // before we process any rendering changes. In short, don't
1160   // try to merge these loops.
1161   for (const auto& observer : observers) {
1162     observer->NotifyEvictedFromRenderingObserverSet();
1163   }
1164   for (const auto& observer : observers) {
1165     observer->OnNonDOMMutationRenderingChange();
1166   }
1167 }
1168
1169 void SVGRenderingObserverSet::InvalidateAllForReflow() {
1170   if (mObservers.IsEmpty()) {
1171     return;
1172   }
1173
1174   AutoTArray<SVGRenderingObserver*, 10> observers;
1175
1176   for (auto it = mObservers.cbegin(), end = mObservers.cend(); it != end;
1177        ++it) {
1178     SVGRenderingObserver* obs = *it;
1179     if (obs->ObservesReflow()) {
1180       observers.AppendElement(obs);
1181       mObservers.Remove(it);
1182       obs->NotifyEvictedFromRenderingObserverSet();
1183     }
1184   }
1185
1186   for (const auto& observer : observers) {
1187     observer->OnNonDOMMutationRenderingChange();
1188   }
1189 }
1190
1191 void SVGRenderingObserverSet::RemoveAll() {
1192   const auto observers = std::move(mObservers);
1193
1194   // Our list is now cleared.  We need to notify the observers we've removed,
1195   // so they can update their state & remove themselves as mutation-observers.
1196   for (const auto& observer : observers) {
1197     observer->NotifyEvictedFromRenderingObserverSet();
1198   }
1199 }
1200
1201 static SVGRenderingObserverSet* GetObserverSet(Element* aElement) {
1202   return static_cast<SVGRenderingObserverSet*>(
1203       aElement->GetProperty(nsGkAtoms::renderingobserverset));
1204 }
1205
1206 #ifdef DEBUG
1207 // Defined down here because we need SVGRenderingObserverSet's definition.
1208 void SVGRenderingObserver::DebugObserverSet() {
1209   Element* referencedElement = GetReferencedElementWithoutObserving();
1210   if (referencedElement) {
1211     SVGRenderingObserverSet* observers = GetObserverSet(referencedElement);
1212     bool inObserverSet = observers && observers->Contains(this);
1213     MOZ_ASSERT(inObserverSet == mInObserverSet,
1214                "failed to track whether we're in our referenced element's "
1215                "observer set!");
1216   } else {
1217     MOZ_ASSERT(!mInObserverSet, "In whose observer set are we, then?");
1218   }
1219 }
1220 #endif
1221
1222 using URIObserverHashtable =
1223     nsInterfaceHashtable<URLAndReferrerInfoHashKey, nsIMutationObserver>;
1224
1225 using PaintingPropertyDescriptor =
1226     const FramePropertyDescriptor<SVGPaintingProperty>*;
1227
1228 static void DestroyFilterProperty(SVGFilterObserverListForCSSProp* aProp) {
1229   aProp->Release();
1230 }
1231
1232 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(HrefToTemplateProperty,
1233                                      SVGTemplateElementObserver)
1234 NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(BackdropFilterProperty,
1235                                     SVGFilterObserverListForCSSProp,
1236                                     DestroyFilterProperty)
1237 NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(FilterProperty,
1238                                     SVGFilterObserverListForCSSProp,
1239                                     DestroyFilterProperty)
1240 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(MaskProperty, SVGMaskObserverList)
1241 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(ClipPathProperty, SVGPaintingProperty)
1242 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(MarkerStartProperty, SVGMarkerObserver)
1243 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(MarkerMidProperty, SVGMarkerObserver)
1244 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(MarkerEndProperty, SVGMarkerObserver)
1245 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(FillProperty, SVGPaintingProperty)
1246 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(StrokeProperty, SVGPaintingProperty)
1247 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(HrefAsTextPathProperty,
1248                                      SVGTextPathObserver)
1249 NS_DECLARE_FRAME_PROPERTY_DELETABLE(BackgroundImageProperty,
1250                                     URIObserverHashtable)
1251 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(BackgroundClipObserverProperty,
1252                                      BackgroundClipRenderingObserver)
1253 NS_DECLARE_FRAME_PROPERTY_RELEASABLE(OffsetPathProperty,
1254                                      SVGRenderingObserverProperty)
1255
1256 template <class T>
1257 static T* GetEffectProperty(URLAndReferrerInfo* aURI, nsIFrame* aFrame,
1258                             const FramePropertyDescriptor<T>* aProperty) {
1259   if (!aURI) {
1260     return nullptr;
1261   }
1262
1263   bool found;
1264   T* prop = aFrame->GetProperty(aProperty, &found);
1265   if (found) {
1266     MOZ_ASSERT(prop, "this property should only store non-null values");
1267     return prop;
1268   }
1269   prop = new T(aURI, aFrame, false);
1270   NS_ADDREF(prop);
1271   aFrame->AddProperty(aProperty, prop);
1272   return prop;
1273 }
1274
1275 static SVGPaintingProperty* GetPaintingProperty(
1276     URLAndReferrerInfo* aURI, nsIFrame* aFrame,
1277     const FramePropertyDescriptor<SVGPaintingProperty>* aProperty) {
1278   return GetEffectProperty(aURI, aFrame, aProperty);
1279 }
1280
1281 static already_AddRefed<URLAndReferrerInfo> GetMarkerURI(
1282     nsIFrame* aFrame, const StyleUrlOrNone nsStyleSVG::*aMarker) {
1283   const StyleUrlOrNone& url = aFrame->StyleSVG()->*aMarker;
1284   if (url.IsNone()) {
1285     return nullptr;
1286   }
1287   return ResolveURLUsingLocalRef(aFrame, url.AsUrl());
1288 }
1289
1290 bool SVGObserverUtils::GetAndObserveMarkers(nsIFrame* aMarkedFrame,
1291                                             SVGMarkerFrame* (*aFrames)[3]) {
1292   MOZ_ASSERT(!aMarkedFrame->GetPrevContinuation() &&
1293                  aMarkedFrame->IsSVGGeometryFrame() &&
1294                  static_cast<SVGGeometryElement*>(aMarkedFrame->GetContent())
1295                      ->IsMarkable(),
1296              "Bad frame");
1297
1298   bool foundMarker = false;
1299   RefPtr<URLAndReferrerInfo> markerURL;
1300   SVGMarkerObserver* observer;
1301   nsIFrame* marker;
1302
1303 #define GET_MARKER(type)                                                    \
1304   markerURL = GetMarkerURI(aMarkedFrame, &nsStyleSVG::mMarker##type);       \
1305   observer =                                                                \
1306       GetEffectProperty(markerURL, aMarkedFrame, Marker##type##Property()); \
1307   marker = observer ? observer->GetAndObserveReferencedFrame(               \
1308                           LayoutFrameType::SVGMarker, nullptr)              \
1309                     : nullptr;                                              \
1310   foundMarker = foundMarker || bool(marker);                                \
1311   (*aFrames)[SVGMark::e##type] = static_cast<SVGMarkerFrame*>(marker);
1312
1313   GET_MARKER(Start)
1314   GET_MARKER(Mid)
1315   GET_MARKER(End)
1316
1317 #undef GET_MARKER
1318
1319   return foundMarker;
1320 }
1321
1322 // Note that the returned list will be empty in the case of a 'filter' property
1323 // that only specifies CSS filter functions (no url()'s to SVG filters).
1324 template <typename P>
1325 static SVGFilterObserverListForCSSProp* GetOrCreateFilterObserverListForCSS(
1326     nsIFrame* aFrame, bool aHasFilters,
1327     FrameProperties::Descriptor<P> aProperty,
1328     Span<const StyleFilter> aFilters) {
1329   if (!aHasFilters) {
1330     return nullptr;
1331   }
1332
1333   bool found;
1334   SVGFilterObserverListForCSSProp* observers =
1335       aFrame->GetProperty(aProperty, &found);
1336   if (found) {
1337     MOZ_ASSERT(observers, "this property should only store non-null values");
1338     return observers;
1339   }
1340   observers = new SVGFilterObserverListForCSSProp(aFilters, aFrame);
1341   NS_ADDREF(observers);
1342   aFrame->AddProperty(aProperty, observers);
1343   return observers;
1344 }
1345
1346 static SVGFilterObserverListForCSSProp* GetOrCreateFilterObserverListForCSS(
1347     nsIFrame* aFrame, StyleFilterType aStyleFilterType) {
1348   MOZ_ASSERT(!aFrame->GetPrevContinuation(), "Require first continuation");
1349
1350   const nsStyleEffects* effects = aFrame->StyleEffects();
1351
1352   return aStyleFilterType == StyleFilterType::BackdropFilter
1353              ? GetOrCreateFilterObserverListForCSS(
1354                    aFrame, effects->HasBackdropFilters(),
1355                    BackdropFilterProperty(), effects->mBackdropFilters.AsSpan())
1356              : GetOrCreateFilterObserverListForCSS(
1357                    aFrame, effects->HasFilters(), FilterProperty(),
1358                    effects->mFilters.AsSpan());
1359 }
1360
1361 static SVGObserverUtils::ReferenceState GetAndObserveFilters(
1362     SVGFilterObserverList* aObserverList,
1363     nsTArray<SVGFilterFrame*>* aFilterFrames) {
1364   if (!aObserverList) {
1365     return SVGObserverUtils::eHasNoRefs;
1366   }
1367
1368   const nsTArray<RefPtr<SVGFilterObserver>>& observers =
1369       aObserverList->GetObservers();
1370   if (observers.IsEmpty()) {
1371     return SVGObserverUtils::eHasNoRefs;
1372   }
1373
1374   for (const auto& observer : observers) {
1375     SVGFilterFrame* filter = observer->GetAndObserveFilterFrame();
1376     if (!filter) {
1377       if (aFilterFrames) {
1378         aFilterFrames->Clear();
1379       }
1380       return SVGObserverUtils::eHasRefsSomeInvalid;
1381     }
1382     if (aFilterFrames) {
1383       aFilterFrames->AppendElement(filter);
1384     }
1385   }
1386
1387   return SVGObserverUtils::eHasRefsAllValid;
1388 }
1389
1390 SVGObserverUtils::ReferenceState SVGObserverUtils::GetAndObserveFilters(
1391     nsIFrame* aFilteredFrame, nsTArray<SVGFilterFrame*>* aFilterFrames,
1392     StyleFilterType aStyleFilterType) {
1393   SVGFilterObserverListForCSSProp* observerList =
1394       GetOrCreateFilterObserverListForCSS(aFilteredFrame, aStyleFilterType);
1395   return mozilla::GetAndObserveFilters(observerList, aFilterFrames);
1396 }
1397
1398 SVGObserverUtils::ReferenceState SVGObserverUtils::GetAndObserveFilters(
1399     nsISupports* aObserverList, nsTArray<SVGFilterFrame*>* aFilterFrames) {
1400   return mozilla::GetAndObserveFilters(
1401       static_cast<SVGFilterObserverListForCanvasContext*>(aObserverList),
1402       aFilterFrames);
1403 }
1404
1405 SVGObserverUtils::ReferenceState SVGObserverUtils::GetFiltersIfObserving(
1406     nsIFrame* aFilteredFrame, nsTArray<SVGFilterFrame*>* aFilterFrames) {
1407   SVGFilterObserverListForCSSProp* observerList =
1408       aFilteredFrame->GetProperty(FilterProperty());
1409   return mozilla::GetAndObserveFilters(observerList, aFilterFrames);
1410 }
1411
1412 already_AddRefed<nsISupports> SVGObserverUtils::ObserveFiltersForCanvasContext(
1413     CanvasRenderingContext2D* aContext, Element* aCanvasElement,
1414     const Span<const StyleFilter> aFilters) {
1415   return do_AddRef(new SVGFilterObserverListForCanvasContext(
1416       aContext, aCanvasElement, aFilters));
1417 }
1418
1419 void SVGObserverUtils::DetachFromCanvasContext(nsISupports* aAutoObserver) {
1420   static_cast<SVGFilterObserverListForCanvasContext*>(aAutoObserver)
1421       ->DetachFromContext();
1422 }
1423
1424 static SVGPaintingProperty* GetOrCreateClipPathObserver(
1425     nsIFrame* aClippedFrame) {
1426   MOZ_ASSERT(!aClippedFrame->GetPrevContinuation(),
1427              "Require first continuation");
1428
1429   const nsStyleSVGReset* svgStyleReset = aClippedFrame->StyleSVGReset();
1430   if (!svgStyleReset->mClipPath.IsUrl()) {
1431     return nullptr;
1432   }
1433   const auto& url = svgStyleReset->mClipPath.AsUrl();
1434   RefPtr<URLAndReferrerInfo> pathURI =
1435       ResolveURLUsingLocalRef(aClippedFrame, url);
1436   return GetPaintingProperty(pathURI, aClippedFrame, ClipPathProperty());
1437 }
1438
1439 SVGObserverUtils::ReferenceState SVGObserverUtils::GetAndObserveClipPath(
1440     nsIFrame* aClippedFrame, SVGClipPathFrame** aClipPathFrame) {
1441   if (aClipPathFrame) {
1442     *aClipPathFrame = nullptr;
1443   }
1444   SVGPaintingProperty* observers = GetOrCreateClipPathObserver(aClippedFrame);
1445   if (!observers) {
1446     return eHasNoRefs;
1447   }
1448   bool frameTypeOK = true;
1449   SVGClipPathFrame* frame =
1450       static_cast<SVGClipPathFrame*>(observers->GetAndObserveReferencedFrame(
1451           LayoutFrameType::SVGClipPath, &frameTypeOK));
1452   // Note that, unlike for filters, a reference to an ID that doesn't exist
1453   // is not invalid for clip-path or mask.
1454   if (!frameTypeOK) {
1455     return eHasRefsSomeInvalid;
1456   }
1457   if (aClipPathFrame) {
1458     *aClipPathFrame = frame;
1459   }
1460   return frame ? eHasRefsAllValid : eHasNoRefs;
1461 }
1462
1463 static SVGRenderingObserverProperty* GetOrCreateGeometryObserver(
1464     nsIFrame* aFrame) {
1465   // Now only offset-path property uses this. See MotionPathUtils.cpp.
1466   const nsStyleDisplay* disp = aFrame->StyleDisplay();
1467   if (!disp->mOffsetPath.IsUrl()) {
1468     return nullptr;
1469   }
1470   const auto& url = disp->mOffsetPath.AsUrl();
1471   RefPtr<URLAndReferrerInfo> pathURI = ResolveURLUsingLocalRef(aFrame, url);
1472   return GetEffectProperty(pathURI, aFrame, OffsetPathProperty());
1473 }
1474
1475 SVGGeometryElement* SVGObserverUtils::GetAndObserveGeometry(nsIFrame* aFrame) {
1476   SVGRenderingObserverProperty* observers = GetOrCreateGeometryObserver(aFrame);
1477   if (!observers) {
1478     return nullptr;
1479   }
1480
1481   bool frameTypeOK = true;
1482   SVGGeometryFrame* frame =
1483       do_QueryFrame(observers->GetAndObserveReferencedFrame(
1484           LayoutFrameType::SVGGeometry, &frameTypeOK));
1485   if (!frameTypeOK || !frame) {
1486     return nullptr;
1487   }
1488
1489   return static_cast<dom::SVGGeometryElement*>(frame->GetContent());
1490 }
1491
1492 static SVGMaskObserverList* GetOrCreateMaskObserverList(
1493     nsIFrame* aMaskedFrame) {
1494   MOZ_ASSERT(!aMaskedFrame->GetPrevContinuation(),
1495              "Require first continuation");
1496
1497   const nsStyleSVGReset* style = aMaskedFrame->StyleSVGReset();
1498   if (!style->HasMask()) {
1499     return nullptr;
1500   }
1501
1502   MOZ_ASSERT(style->mMask.mImageCount > 0);
1503
1504   bool found;
1505   SVGMaskObserverList* prop = aMaskedFrame->GetProperty(MaskProperty(), &found);
1506   if (found) {
1507     MOZ_ASSERT(prop, "this property should only store non-null values");
1508     return prop;
1509   }
1510   prop = new SVGMaskObserverList(aMaskedFrame);
1511   NS_ADDREF(prop);
1512   aMaskedFrame->AddProperty(MaskProperty(), prop);
1513   return prop;
1514 }
1515
1516 SVGObserverUtils::ReferenceState SVGObserverUtils::GetAndObserveMasks(
1517     nsIFrame* aMaskedFrame, nsTArray<SVGMaskFrame*>* aMaskFrames) {
1518   SVGMaskObserverList* observerList = GetOrCreateMaskObserverList(aMaskedFrame);
1519   if (!observerList) {
1520     return eHasNoRefs;
1521   }
1522
1523   const nsTArray<RefPtr<SVGPaintingProperty>>& observers =
1524       observerList->GetObservers();
1525   if (observers.IsEmpty()) {
1526     return eHasNoRefs;
1527   }
1528
1529   ReferenceState state = eHasRefsAllValid;
1530
1531   for (size_t i = 0; i < observers.Length(); i++) {
1532     bool frameTypeOK = true;
1533     SVGMaskFrame* maskFrame =
1534         static_cast<SVGMaskFrame*>(observers[i]->GetAndObserveReferencedFrame(
1535             LayoutFrameType::SVGMask, &frameTypeOK));
1536     MOZ_ASSERT(!maskFrame || frameTypeOK);
1537     // XXXjwatt: this looks fishy
1538     if (!frameTypeOK) {
1539       // We can not find the specific SVG mask resource in the downloaded SVG
1540       // document. There are two possibilities:
1541       // 1. The given resource id is invalid.
1542       // 2. The given resource id refers to a viewbox.
1543       //
1544       // Hand it over to the style image.
1545       observerList->ResolveImage(i);
1546       state = eHasRefsSomeInvalid;
1547     }
1548     if (aMaskFrames) {
1549       aMaskFrames->AppendElement(maskFrame);
1550     }
1551   }
1552
1553   return state;
1554 }
1555
1556 SVGGeometryElement* SVGObserverUtils::GetAndObserveTextPathsPath(
1557     nsIFrame* aTextPathFrame) {
1558   // Continuations can come and go during reflow, and we don't need to observe
1559   // the referenced element more than once for a given node.
1560   aTextPathFrame = aTextPathFrame->FirstContinuation();
1561
1562   SVGTextPathObserver* property =
1563       aTextPathFrame->GetProperty(HrefAsTextPathProperty());
1564
1565   if (!property) {
1566     nsIContent* content = aTextPathFrame->GetContent();
1567     nsAutoString href;
1568     static_cast<SVGTextPathElement*>(content)->HrefAsString(href);
1569     if (href.IsEmpty()) {
1570       return nullptr;  // no URL
1571     }
1572
1573     RefPtr<URLAndReferrerInfo> target = ResolveURLUsingLocalRef(content, href);
1574
1575     property =
1576         GetEffectProperty(target, aTextPathFrame, HrefAsTextPathProperty());
1577     if (!property) {
1578       return nullptr;
1579     }
1580   }
1581
1582   return SVGGeometryElement::FromNodeOrNull(
1583       property->GetAndObserveReferencedElement());
1584 }
1585
1586 SVGGeometryElement* SVGObserverUtils::GetAndObserveMPathsPath(
1587     SVGMPathElement* aSVGMPathElement) {
1588   if (!aSVGMPathElement->mMPathObserver) {
1589     nsAutoString href;
1590     aSVGMPathElement->HrefAsString(href);
1591     if (href.IsEmpty()) {
1592       return nullptr;  // no URL
1593     }
1594
1595     RefPtr<URLAndReferrerInfo> target =
1596         ResolveURLUsingLocalRef(aSVGMPathElement, href);
1597
1598     aSVGMPathElement->mMPathObserver =
1599         new SVGMPathObserver(target, aSVGMPathElement);
1600   }
1601
1602   return SVGGeometryElement::FromNodeOrNull(
1603       static_cast<SVGMPathObserver*>(aSVGMPathElement->mMPathObserver.get())
1604           ->GetAndObserveReferencedElement());
1605 }
1606
1607 void SVGObserverUtils::TraverseMPathObserver(
1608     SVGMPathElement* aSVGMPathElement,
1609     nsCycleCollectionTraversalCallback* aCB) {
1610   if (aSVGMPathElement->mMPathObserver) {
1611     static_cast<SVGMPathObserver*>(aSVGMPathElement->mMPathObserver.get())
1612         ->Traverse(aCB);
1613   }
1614 }
1615
1616 void SVGObserverUtils::InitiateResourceDocLoads(nsIFrame* aFrame) {
1617   // We create observer objects and attach them to aFrame, but we do not
1618   // make aFrame start observing the referenced frames.
1619   Unused << GetOrCreateFilterObserverListForCSS(
1620       aFrame, StyleFilterType::BackdropFilter);
1621   Unused << GetOrCreateFilterObserverListForCSS(aFrame,
1622                                                 StyleFilterType::Filter);
1623   Unused << GetOrCreateClipPathObserver(aFrame);
1624   Unused << GetOrCreateGeometryObserver(aFrame);
1625   Unused << GetOrCreateMaskObserverList(aFrame);
1626 }
1627
1628 void SVGObserverUtils::RemoveTextPathObserver(nsIFrame* aTextPathFrame) {
1629   aTextPathFrame->RemoveProperty(HrefAsTextPathProperty());
1630 }
1631
1632 nsIFrame* SVGObserverUtils::GetAndObserveTemplate(
1633     nsIFrame* aFrame, HrefToTemplateCallback aGetHref) {
1634   SVGTemplateElementObserver* observer =
1635       aFrame->GetProperty(HrefToTemplateProperty());
1636
1637   if (!observer) {
1638     nsAutoString href;
1639     aGetHref(href);
1640     if (href.IsEmpty()) {
1641       return nullptr;  // no URL
1642     }
1643
1644     RefPtr<URLAndReferrerInfo> info =
1645         ResolveURLUsingLocalRef(aFrame->GetContent(), href);
1646
1647     observer = GetEffectProperty(info, aFrame, HrefToTemplateProperty());
1648   }
1649
1650   return observer ? observer->GetAndObserveReferencedFrame() : nullptr;
1651 }
1652
1653 void SVGObserverUtils::RemoveTemplateObserver(nsIFrame* aFrame) {
1654   aFrame->RemoveProperty(HrefToTemplateProperty());
1655 }
1656
1657 Element* SVGObserverUtils::GetAndObserveBackgroundImage(nsIFrame* aFrame,
1658                                                         const nsAtom* aHref) {
1659   bool found;
1660   URIObserverHashtable* hashtable =
1661       aFrame->GetProperty(BackgroundImageProperty(), &found);
1662   if (!found) {
1663     hashtable = new URIObserverHashtable();
1664     aFrame->AddProperty(BackgroundImageProperty(), hashtable);
1665   } else {
1666     MOZ_ASSERT(hashtable, "this property should only store non-null values");
1667   }
1668
1669   nsAutoString elementId = u"#"_ns + nsDependentAtomString(aHref);
1670   nsCOMPtr<nsIURI> targetURI;
1671   nsContentUtils::NewURIWithDocumentCharset(
1672       getter_AddRefs(targetURI), elementId,
1673       aFrame->GetContent()->GetUncomposedDoc(),
1674       aFrame->GetContent()->GetBaseURI());
1675   nsIReferrerInfo* referrerInfo =
1676       aFrame->GetContent()
1677           ->OwnerDoc()
1678           ->ReferrerInfoForInternalCSSAndSVGResources();
1679   RefPtr<URLAndReferrerInfo> url =
1680       new URLAndReferrerInfo(targetURI, referrerInfo);
1681
1682   return static_cast<SVGMozElementObserver*>(
1683              hashtable
1684                  ->LookupOrInsertWith(
1685                      url,
1686                      [&] {
1687                        return MakeRefPtr<SVGMozElementObserver>(url, aFrame);
1688                      })
1689                  .get())
1690       ->GetAndObserveReferencedElement();
1691 }
1692
1693 Element* SVGObserverUtils::GetAndObserveBackgroundClip(nsIFrame* aFrame) {
1694   bool found;
1695   BackgroundClipRenderingObserver* obs =
1696       aFrame->GetProperty(BackgroundClipObserverProperty(), &found);
1697   if (!found) {
1698     obs = new BackgroundClipRenderingObserver(aFrame);
1699     NS_ADDREF(obs);
1700     aFrame->AddProperty(BackgroundClipObserverProperty(), obs);
1701   }
1702
1703   return obs->GetAndObserveReferencedElement();
1704 }
1705
1706 SVGPaintServerFrame* SVGObserverUtils::GetAndObservePaintServer(
1707     nsIFrame* aPaintedFrame, StyleSVGPaint nsStyleSVG::*aPaint) {
1708   // If we're looking at a frame within SVG text, then we need to look up
1709   // to find the right frame to get the painting property off.  We should at
1710   // least look up past a text frame, and if the text frame's parent is the
1711   // anonymous block frame, then we look up to its parent (the SVGTextFrame).
1712   nsIFrame* paintedFrame = aPaintedFrame;
1713   if (paintedFrame->IsInSVGTextSubtree()) {
1714     paintedFrame = paintedFrame->GetParent();
1715     nsIFrame* grandparent = paintedFrame->GetParent();
1716     if (grandparent && grandparent->IsSVGTextFrame()) {
1717       paintedFrame = grandparent;
1718     }
1719   }
1720
1721   const nsStyleSVG* svgStyle = paintedFrame->StyleSVG();
1722   if (!(svgStyle->*aPaint).kind.IsPaintServer()) {
1723     return nullptr;
1724   }
1725
1726   RefPtr<URLAndReferrerInfo> paintServerURL = ResolveURLUsingLocalRef(
1727       paintedFrame, (svgStyle->*aPaint).kind.AsPaintServer());
1728
1729   MOZ_ASSERT(aPaint == &nsStyleSVG::mFill || aPaint == &nsStyleSVG::mStroke);
1730   PaintingPropertyDescriptor propDesc =
1731       (aPaint == &nsStyleSVG::mFill) ? FillProperty() : StrokeProperty();
1732   if (auto* property =
1733           GetPaintingProperty(paintServerURL, paintedFrame, propDesc)) {
1734     return do_QueryFrame(property->GetAndObserveReferencedFrame());
1735   }
1736   return nullptr;
1737 }
1738
1739 void SVGObserverUtils::UpdateEffects(nsIFrame* aFrame) {
1740   NS_ASSERTION(aFrame->GetContent()->IsElement(),
1741                "aFrame's content should be an element");
1742
1743   aFrame->RemoveProperty(BackdropFilterProperty());
1744   aFrame->RemoveProperty(FilterProperty());
1745   aFrame->RemoveProperty(MaskProperty());
1746   aFrame->RemoveProperty(ClipPathProperty());
1747   aFrame->RemoveProperty(MarkerStartProperty());
1748   aFrame->RemoveProperty(MarkerMidProperty());
1749   aFrame->RemoveProperty(MarkerEndProperty());
1750   aFrame->RemoveProperty(FillProperty());
1751   aFrame->RemoveProperty(StrokeProperty());
1752   aFrame->RemoveProperty(BackgroundImageProperty());
1753
1754   // Ensure that the filter is repainted correctly
1755   // We can't do that in OnRenderingChange as the referenced frame may
1756   // not be valid
1757   GetOrCreateFilterObserverListForCSS(aFrame, StyleFilterType::BackdropFilter);
1758   GetOrCreateFilterObserverListForCSS(aFrame, StyleFilterType::Filter);
1759
1760   if (aFrame->IsSVGGeometryFrame() &&
1761       static_cast<SVGGeometryElement*>(aFrame->GetContent())->IsMarkable()) {
1762     // Set marker properties here to avoid reference loops
1763     RefPtr<URLAndReferrerInfo> markerURL =
1764         GetMarkerURI(aFrame, &nsStyleSVG::mMarkerStart);
1765     GetEffectProperty(markerURL, aFrame, MarkerStartProperty());
1766     markerURL = GetMarkerURI(aFrame, &nsStyleSVG::mMarkerMid);
1767     GetEffectProperty(markerURL, aFrame, MarkerMidProperty());
1768     markerURL = GetMarkerURI(aFrame, &nsStyleSVG::mMarkerEnd);
1769     GetEffectProperty(markerURL, aFrame, MarkerEndProperty());
1770   }
1771 }
1772
1773 void SVGObserverUtils::AddRenderingObserver(Element* aElement,
1774                                             SVGRenderingObserver* aObserver) {
1775   SVGRenderingObserverSet* observers = GetObserverSet(aElement);
1776   if (!observers) {
1777     observers = new SVGRenderingObserverSet();
1778     // When we call cloneAndAdopt we keep the property. If the referenced
1779     // element doesn't exist in the new document then the observer set and
1780     // observers will be removed by ElementTracker::ElementChanged when we
1781     // get the ChangeNotification.
1782     aElement->SetProperty(nsGkAtoms::renderingobserverset, observers,
1783                           nsINode::DeleteProperty<SVGRenderingObserverSet>,
1784                           /* aTransfer = */ true);
1785   }
1786   aElement->SetHasRenderingObservers(true);
1787   observers->Add(aObserver);
1788 }
1789
1790 void SVGObserverUtils::RemoveRenderingObserver(
1791     Element* aElement, SVGRenderingObserver* aObserver) {
1792   SVGRenderingObserverSet* observers = GetObserverSet(aElement);
1793   if (observers) {
1794     NS_ASSERTION(observers->Contains(aObserver),
1795                  "removing observer from an element we're not observing?");
1796     observers->Remove(aObserver);
1797     if (observers->IsEmpty()) {
1798       aElement->RemoveProperty(nsGkAtoms::renderingobserverset);
1799       aElement->SetHasRenderingObservers(false);
1800     }
1801   }
1802 }
1803
1804 void SVGObserverUtils::RemoveAllRenderingObservers(Element* aElement) {
1805   SVGRenderingObserverSet* observers = GetObserverSet(aElement);
1806   if (observers) {
1807     observers->RemoveAll();
1808     aElement->RemoveProperty(nsGkAtoms::renderingobserverset);
1809     aElement->SetHasRenderingObservers(false);
1810   }
1811 }
1812
1813 void SVGObserverUtils::InvalidateRenderingObservers(nsIFrame* aFrame) {
1814   NS_ASSERTION(!aFrame->GetPrevContinuation(),
1815                "aFrame must be first continuation");
1816
1817   auto* element = Element::FromNodeOrNull(aFrame->GetContent());
1818   if (!element) {
1819     return;
1820   }
1821
1822   // If the rendering has changed, the bounds may well have changed too:
1823   aFrame->RemoveProperty(SVGUtils::ObjectBoundingBoxProperty());
1824
1825   if (auto* observers = GetObserverSet(element)) {
1826     observers->InvalidateAll();
1827     return;
1828   }
1829
1830   if (aFrame->IsRenderingObserverContainer()) {
1831     return;
1832   }
1833
1834   // Check ancestor SVG containers. The root frame cannot be of type
1835   // eSVGContainer so we don't have to check f for null here.
1836   for (nsIFrame* f = aFrame->GetParent(); f->IsSVGContainerFrame();
1837        f = f->GetParent()) {
1838     if (auto* element = Element::FromNode(f->GetContent())) {
1839       if (auto* observers = GetObserverSet(element)) {
1840         observers->InvalidateAll();
1841         return;
1842       }
1843     }
1844     if (f->IsRenderingObserverContainer()) {
1845       return;
1846     }
1847   }
1848 }
1849
1850 void SVGObserverUtils::InvalidateDirectRenderingObservers(
1851     Element* aElement, uint32_t aFlags /* = 0 */) {
1852   if (nsIFrame* frame = aElement->GetPrimaryFrame()) {
1853     // If the rendering has changed, the bounds may well have changed too:
1854     frame->RemoveProperty(SVGUtils::ObjectBoundingBoxProperty());
1855   }
1856
1857   if (aElement->HasRenderingObservers()) {
1858     SVGRenderingObserverSet* observers = GetObserverSet(aElement);
1859     if (observers) {
1860       if (aFlags & INVALIDATE_REFLOW) {
1861         observers->InvalidateAllForReflow();
1862       } else {
1863         observers->InvalidateAll();
1864       }
1865     }
1866   }
1867 }
1868
1869 void SVGObserverUtils::InvalidateDirectRenderingObservers(
1870     nsIFrame* aFrame, uint32_t aFlags /* = 0 */) {
1871   if (auto* element = Element::FromNodeOrNull(aFrame->GetContent())) {
1872     InvalidateDirectRenderingObservers(element, aFlags);
1873   }
1874 }
1875
1876 }  // namespace mozilla