dom/base/FragmentOrElement.h

   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 /*
   8  * Base class for all element classes as well as nsDocumentFragment.  This
   9  * provides an implementation of nsINode, implements nsIContent, provides
  10  * utility methods for subclasses, and so forth.
  11  */
  12
  13 #ifndef FragmentOrElement_h___
  14 #define FragmentOrElement_h___
  15
  16 #include "mozilla/Attributes.h"
  17 #include "mozilla/EnumSet.h"
  18 #include "mozilla/MemoryReporting.h"
  19 #include "mozilla/UniquePtr.h"
  20 #include "mozilla/dom/RadioGroupContainer.h"
  21 #include "nsCycleCollectionParticipant.h"  // NS_DECL_CYCLE_*
  22 #include "nsIContent.h"                    // base class
  23 #include "nsAtomHashKeys.h"
  24 #include "nsIHTMLCollection.h"
  25 #include "nsIWeakReferenceUtils.h"
  26
  27 class ContentUnbinder;
  28 class nsContentList;
  29 class nsLabelsNodeList;
  30 class nsDOMAttributeMap;
  31 class nsDOMTokenList;
  32 class nsIControllers;
  33 class nsICSSDeclaration;
  34 class nsDOMCSSAttributeDeclaration;
  35 class nsDOMStringMap;
  36 class nsIURI;
  37
  38 namespace mozilla {
  39 class DeclarationBlock;
  40 enum class ContentRelevancyReason;
  41 using ContentRelevancy = EnumSet<ContentRelevancyReason, uint8_t>;
  42 class ElementAnimationData;
  43 namespace dom {
  44 struct CustomElementData;
  45 class Element;
  46 class PopoverData;
  47 }  // namespace dom
  48 }  // namespace mozilla
  49
  50 /**
  51  * Tearoff to use for nodes to implement nsISupportsWeakReference
  52  */
  53 class nsNodeSupportsWeakRefTearoff final : public nsISupportsWeakReference {
  54  public:
  55   explicit nsNodeSupportsWeakRefTearoff(nsINode* aNode) : mNode(aNode) {}
  56
  57   // nsISupports
  58   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  59
  60   // nsISupportsWeakReference
  61   NS_DECL_NSISUPPORTSWEAKREFERENCE
  62
  63   NS_DECL_CYCLE_COLLECTION_CLASS(nsNodeSupportsWeakRefTearoff)
  64
  65  private:
  66   ~nsNodeSupportsWeakRefTearoff() = default;
  67
  68   nsCOMPtr<nsINode> mNode;
  69 };
  70
  71 /**
  72  * A generic base class for DOM elements and document fragments,
  73  * implementing many nsIContent, nsINode and Element methods.
  74  */
  75 namespace mozilla::dom {
  76
  77 class ShadowRoot;
  78
  79 class FragmentOrElement : public nsIContent {
  80  public:
  81   explicit FragmentOrElement(
  82       already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
  83   explicit FragmentOrElement(
  84       already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
  85
  86   // We want to avoid the overhead of extra function calls for
  87   // refcounting when we're not doing refcount logging, so we can't
  88   // NS_DECL_ISUPPORTS_INHERITED.
  89   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
  90   NS_INLINE_DECL_REFCOUNTING_INHERITED(FragmentOrElement, nsIContent);
  91
  92   NS_DECL_ADDSIZEOFEXCLUDINGTHIS
  93
  94   // nsINode interface methods
  95   virtual void GetTextContentInternal(nsAString& aTextContent,
  96                                       mozilla::OOMReporter& aError) override;
  97   virtual void SetTextContentInternal(const nsAString& aTextContent,
  98                                       nsIPrincipal* aSubjectPrincipal,
  99                                       mozilla::ErrorResult& aError) override;
 100
 101   // nsIContent interface methods
 102   const nsTextFragment* GetText() override;
 103   uint32_t TextLength() const override;
 104   bool TextIsOnlyWhitespace() override;
 105   bool ThreadSafeTextIsOnlyWhitespace() const override;
 106
 107   void DestroyContent() override;
 108   void SaveSubtreeState() override;
 109
 110   nsIHTMLCollection* Children();
 111   uint32_t ChildElementCount() {
 112     if (!HasChildren()) {
 113       return 0;
 114     }
 115     return Children()->Length();
 116   }
 117
 118   RadioGroupContainer& OwnedRadioGroupContainer() {
 119     auto* slots = ExtendedDOMSlots();
 120     if (!slots->mRadioGroupContainer) {
 121       slots->mRadioGroupContainer = MakeUnique<RadioGroupContainer>();
 122     }
 123     return *slots->mRadioGroupContainer;
 124   }
 125
 126  public:
 127   /**
 128    * If there are listeners for DOMNodeInserted event, fires the event on all
 129    * aNodes
 130    */
 131   static void FireNodeInserted(Document* aDoc, nsINode* aParent,
 132                                const nsTArray<nsCOMPtr<nsIContent>>& aNodes);
 133
 134   NS_DECL_CYCLE_COLLECTION_SKIPPABLE_WRAPPERCACHE_CLASS_INHERITED(
 135       FragmentOrElement, nsIContent)
 136
 137   static void ClearContentUnbinder();
 138   static bool CanSkip(nsINode* aNode, bool aRemovingAllowed);
 139   static bool CanSkipInCC(nsINode* aNode);
 140   static bool CanSkipThis(nsINode* aNode);
 141   static void RemoveBlackMarkedNode(nsINode* aNode);
 142   static void MarkNodeChildren(nsINode* aNode);
 143   static void InitCCCallbacks();
 144
 145   /**
 146    * Is the HTML local name a void element?
 147    */
 148   static bool IsHTMLVoid(nsAtom* aLocalName);
 149
 150  protected:
 151   virtual ~FragmentOrElement();
 152
 153   /**
 154    * Dummy CopyInnerTo so that we can use the same macros for
 155    * Elements and DocumentFragments.
 156    */
 157   nsresult CopyInnerTo(FragmentOrElement* aDest) { return NS_OK; }
 158
 159  public:
 160   /**
 161    * There are a set of DOM- and scripting-specific instance variables
 162    * that may only be instantiated when a content object is accessed
 163    * through the DOM. Rather than burn actual slots in the content
 164    * objects for each of these instance variables, we put them off
 165    * in a side structure that's only allocated when the content is
 166    * accessed through the DOM.
 167    */
 168
 169   class nsExtendedDOMSlots : public nsIContent::nsExtendedContentSlots {
 170    public:
 171     nsExtendedDOMSlots();
 172     ~nsExtendedDOMSlots();
 173
 174     void TraverseExtendedSlots(nsCycleCollectionTraversalCallback&) final;
 175     void UnlinkExtendedSlots(nsIContent&) final;
 176
 177     size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const final;
 178
 179     /**
 180      * SMIL Overridde style rules (for SMIL animation of CSS properties)
 181      * @see Element::GetSMILOverrideStyle
 182      */
 183     RefPtr<nsDOMCSSAttributeDeclaration> mSMILOverrideStyle;
 184
 185     /**
 186      * Holds any SMIL override style declaration for this element.
 187      */
 188     RefPtr<DeclarationBlock> mSMILOverrideStyleDeclaration;
 189
 190     /**
 191      * The controllers of the XUL Element.
 192      */
 193     nsCOMPtr<nsIControllers> mControllers;
 194
 195     /**
 196      * An object implementing the .labels property for this element.
 197      */
 198     RefPtr<nsLabelsNodeList> mLabelsList;
 199
 200     /**
 201      * ShadowRoot bound to the element.
 202      */
 203     RefPtr<ShadowRoot> mShadowRoot;
 204
 205     /**
 206      * Web components custom element data.
 207      */
 208     UniquePtr<CustomElementData> mCustomElementData;
 209
 210     /**
 211      * Web animations data.
 212      */
 213     UniquePtr<ElementAnimationData> mAnimations;
 214
 215     /**
 216      * PopoverData for the element.
 217      */
 218     UniquePtr<PopoverData> mPopoverData;
 219
 220     /**
 221      * CustomStates for the element.
 222      */
 223     nsTArray<RefPtr<nsAtom>> mCustomStates;
 224
 225     /**
 226      * RadioGroupContainer for radio buttons grouped under this disconnected
 227      * element.
 228      */
 229     UniquePtr<RadioGroupContainer> mRadioGroupContainer;
 230
 231     /**
 232      * Last remembered size (in CSS pixels) for the element.
 233      * @see {@link https://drafts.csswg.org/css-sizing-4/#last-remembered}
 234      */
 235     Maybe<float> mLastRememberedBSize;
 236     Maybe<float> mLastRememberedISize;
 237
 238     /**
 239      * Whether the content of this element is relevant for the purposes
 240      * of `content-visibility: auto.
 241      * Reflects 'relevant to the user' concept, see
 242      * https://drafts.csswg.org/css-contain/#relevant-to-the-user.
 243      */
 244     Maybe<ContentRelevancy> mContentRelevancy;
 245
 246     /**
 247      * Whether the content of this element is considered visible for
 248      * the purposes of `content-visibility: auto.
 249      * Reflects 'proximity to the viewport' concept, see
 250      * https://drafts.csswg.org/css-contain/#proximity-to-the-viewport.
 251      */
 252     Maybe<bool> mVisibleForContentVisibility;
 253
 254     /**
 255      * Whether content-visibility: auto is temporarily visible for
 256      * the purposes of the descendant of scrollIntoView.
 257      */
 258     bool mTemporarilyVisibleForScrolledIntoViewDescendant = false;
 259
 260     /**
 261      * Explicitly set attr-elements, see
 262      * https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#explicitly-set-attr-element
 263      */
 264     nsTHashMap<RefPtr<nsAtom>, nsWeakPtr> mExplicitlySetAttrElements;
 265   };
 266
 267   class nsDOMSlots : public nsIContent::nsContentSlots {
 268    public:
 269     nsDOMSlots();
 270     ~nsDOMSlots();
 271
 272     void Traverse(nsCycleCollectionTraversalCallback&) final;
 273     void Unlink(nsINode&) final;
 274
 275     size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 276
 277     /**
 278      * The .style attribute (an interface that forwards to the actual
 279      * style rules)
 280      * @see nsGenericHTMLElement::GetStyle
 281      */
 282     nsCOMPtr<nsICSSDeclaration> mStyle;
 283
 284     /**
 285      * The .dataset attribute.
 286      * @see nsGenericHTMLElement::GetDataset
 287      */
 288     nsDOMStringMap* mDataset;  // [Weak]
 289
 290     /**
 291      * @see Element::Attributes
 292      */
 293     RefPtr<nsDOMAttributeMap> mAttributeMap;
 294
 295     /**
 296      * An object implementing the .children property for this element.
 297      */
 298     RefPtr<nsContentList> mChildrenList;
 299
 300     /**
 301      * An object implementing the .classList property for this element.
 302      */
 303     RefPtr<nsDOMTokenList> mClassList;
 304
 305     /**
 306      * An object implementing the .part property for this element.
 307      */
 308     RefPtr<nsDOMTokenList> mPart;
 309   };
 310
 311   /**
 312    * In case ExtendedDOMSlots is needed before normal DOMSlots, an instance of
 313    * FatSlots class, which combines those two slot types, is created.
 314    * This way we can avoid extra allocation for ExtendedDOMSlots.
 315    * FatSlots is useful for example when creating Custom Elements.
 316    */
 317   class FatSlots final : public nsDOMSlots, public nsExtendedDOMSlots {
 318    public:
 319     FatSlots() : nsDOMSlots(), nsExtendedDOMSlots() {
 320       MOZ_COUNT_CTOR(FatSlots);
 321       SetExtendedContentSlots(this, false);
 322     }
 323
 324     ~FatSlots() final { MOZ_COUNT_DTOR(FatSlots); }
 325   };
 326
 327  protected:
 328   void GetMarkup(bool aIncludeSelf, nsAString& aMarkup);
 329   void SetInnerHTMLInternal(const nsAString& aInnerHTML, ErrorResult& aError);
 330
 331   // Override from nsINode
 332   nsIContent::nsContentSlots* CreateSlots() override {
 333     return new nsDOMSlots();
 334   }
 335
 336   nsIContent::nsExtendedContentSlots* CreateExtendedSlots() final {
 337     return new nsExtendedDOMSlots();
 338   }
 339
 340   nsDOMSlots* DOMSlots() { return static_cast<nsDOMSlots*>(Slots()); }
 341
 342   nsDOMSlots* GetExistingDOMSlots() const {
 343     return static_cast<nsDOMSlots*>(GetExistingSlots());
 344   }
 345
 346   nsExtendedDOMSlots* ExtendedDOMSlots() {
 347     nsContentSlots* slots = GetExistingContentSlots();
 348     if (!slots) {
 349       FatSlots* fatSlots = new FatSlots();
 350       mSlots = fatSlots;
 351       return fatSlots;
 352     }
 353
 354     if (!slots->GetExtendedContentSlots()) {
 355       slots->SetExtendedContentSlots(CreateExtendedSlots(), true);
 356     }
 357
 358     return static_cast<nsExtendedDOMSlots*>(slots->GetExtendedContentSlots());
 359   }
 360
 361   const nsExtendedDOMSlots* GetExistingExtendedDOMSlots() const {
 362     return static_cast<const nsExtendedDOMSlots*>(
 363         GetExistingExtendedContentSlots());
 364   }
 365
 366   nsExtendedDOMSlots* GetExistingExtendedDOMSlots() {
 367     return static_cast<nsExtendedDOMSlots*>(GetExistingExtendedContentSlots());
 368   }
 369
 370   friend class ::ContentUnbinder;
 371 };
 372
 373 }  // namespace mozilla::dom
 374
 375 #define NS_ELEMENT_INTERFACE_TABLE_TO_MAP_SEGUE               \
 376   if (NS_SUCCEEDED(rv)) return rv;                            \
 377                                                               \
 378   rv = FragmentOrElement::QueryInterface(aIID, aInstancePtr); \
 379   NS_INTERFACE_TABLE_TO_MAP_SEGUE
 380
 381 #endif /* FragmentOrElement_h___ */