dom/base/ShadowRoot.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 #ifndef mozilla_dom_shadowroot_h__
   8 #define mozilla_dom_shadowroot_h__
   9
  10 #include "mozilla/dom/DocumentBinding.h"
  11 #include "mozilla/dom/DocumentFragment.h"
  12 #include "mozilla/dom/DocumentOrShadowRoot.h"
  13 #include "mozilla/dom/NameSpaceConstants.h"
  14 #include "mozilla/dom/ShadowRootBinding.h"
  15 #include "mozilla/ServoBindings.h"
  16 #include "nsCOMPtr.h"
  17 #include "nsCycleCollectionParticipant.h"
  18 #include "nsIRadioGroupContainer.h"
  19 #include "nsStubMutationObserver.h"
  20 #include "nsTHashtable.h"
  21
  22 class nsAtom;
  23 class nsIContent;
  24 class nsXBLPrototypeBinding;
  25
  26 namespace mozilla {
  27
  28 class EventChainPreVisitor;
  29 class ServoStyleRuleMap;
  30
  31 enum class StyleRuleChangeKind : uint32_t;
  32
  33 namespace css {
  34 class Rule;
  35 }
  36
  37 namespace dom {
  38
  39 class CSSImportRule;
  40 class Element;
  41 class HTMLInputElement;
  42
  43 class ShadowRoot final : public DocumentFragment,
  44                          public DocumentOrShadowRoot,
  45                          public nsIRadioGroupContainer {
  46   friend class DocumentOrShadowRoot;
  47
  48  public:
  49   NS_IMPL_FROMNODE_HELPER(ShadowRoot, IsShadowRoot());
  50
  51   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ShadowRoot, DocumentFragment)
  52   NS_DECL_ISUPPORTS_INHERITED
  53
  54   ShadowRoot(Element* aElement, ShadowRootMode aMode,
  55              already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
  56
  57   void AddSizeOfExcludingThis(nsWindowSizes&, size_t* aNodeSize) const final;
  58
  59   // Try to reassign an element to a slot.
  60   void MaybeReassignElement(Element&);
  61   // Called when an element is inserted as a direct child of our host. Tries to
  62   // slot the child in one of our slots.
  63   void MaybeSlotHostChild(nsIContent&);
  64   // Called when a direct child of our host is removed. Tries to un-slot the
  65   // child from the currently-assigned slot, if any.
  66   void MaybeUnslotHostChild(nsIContent&);
  67
  68   // Shadow DOM v1
  69   Element* Host() const {
  70     MOZ_ASSERT(GetHost(),
  71                "ShadowRoot always has a host, how did we create "
  72                "this ShadowRoot?");
  73     return GetHost();
  74   }
  75
  76   ShadowRootMode Mode() const { return mMode; }
  77   bool IsClosed() const { return mMode == ShadowRootMode::Closed; }
  78
  79   void RemoveSheetFromStyles(StyleSheet&);
  80   void RuleAdded(StyleSheet&, css::Rule&);
  81   void RuleRemoved(StyleSheet&, css::Rule&);
  82   void RuleChanged(StyleSheet&, css::Rule*, StyleRuleChangeKind);
  83   void ImportRuleLoaded(CSSImportRule&, StyleSheet&);
  84   void SheetCloned(StyleSheet&);
  85   void StyleSheetApplicableStateChanged(StyleSheet&);
  86
  87   /**
  88    * Clones internal state, for example stylesheets, of aOther to 'this'.
  89    */
  90   void CloneInternalDataFrom(ShadowRoot* aOther);
  91   void InsertSheetAt(size_t aIndex, StyleSheet&);
  92
  93   // Calls UnbindFromTree for each of our kids, and also flags us as no longer
  94   // being connected.
  95   void Unbind();
  96
  97   // Only intended for UA widgets / special shadow roots, or for handling
  98   // failure cases when adopting (see BlastSubtreeToPieces).
  99   //
 100   // Forgets our shadow host and unbinds all our kids.
 101   void Unattach();
 102
 103   // Calls BindToTree on each of our kids, and also maybe flags us as being
 104   // connected.
 105   nsresult Bind();
 106
 107  private:
 108   void InsertSheetIntoAuthorData(size_t aIndex, StyleSheet&,
 109                                  const nsTArray<RefPtr<StyleSheet>>&);
 110
 111   void AppendStyleSheet(StyleSheet& aSheet) {
 112     InsertSheetAt(SheetCount(), aSheet);
 113   }
 114
 115   /**
 116    * Represents the insertion point in a slot for a given node.
 117    */
 118   struct SlotAssignment {
 119     HTMLSlotElement* mSlot = nullptr;
 120     Maybe<uint32_t> mIndex;
 121
 122     SlotAssignment() = default;
 123     SlotAssignment(HTMLSlotElement* aSlot, const Maybe<uint32_t>& aIndex)
 124         : mSlot(aSlot), mIndex(aIndex) {}
 125   };
 126
 127   /**
 128    * Return the assignment corresponding to the content node at this particular
 129    * point in time.
 130    *
 131    * It's the caller's responsibility to actually call InsertAssignedNode /
 132    * AppendAssignedNode in the slot as needed.
 133    */
 134   SlotAssignment SlotAssignmentFor(nsIContent&);
 135
 136   /**
 137    * Explicitly invalidates the style and layout of the flattened-tree subtree
 138    * rooted at the element.
 139    *
 140    * You need to use this whenever the flat tree is going to be shuffled in a
 141    * way that layout doesn't understand via the usual ContentInserted /
 142    * ContentAppended / ContentRemoved notifications. For example, if removing an
 143    * element will cause a change in the flat tree such that other element will
 144    * start showing up (like fallback content), this method needs to be called on
 145    * an ancestor of that element.
 146    *
 147    * It is important that this runs _before_ actually shuffling the flat tree
 148    * around, so that layout knows the actual tree that it needs to invalidate.
 149    */
 150   void InvalidateStyleAndLayoutOnSubtree(Element*);
 151
 152  public:
 153   void AddSlot(HTMLSlotElement* aSlot);
 154   void RemoveSlot(HTMLSlotElement* aSlot);
 155   bool HasSlots() const { return !mSlotMap.IsEmpty(); };
 156   HTMLSlotElement* GetDefaultSlot() const {
 157     SlotArray* list = mSlotMap.Get(u""_ns);
 158     return list ? (*list)->ElementAt(0) : nullptr;
 159   }
 160
 161   void PartAdded(const Element&);
 162   void PartRemoved(const Element&);
 163
 164   const nsTArray<const Element*>& Parts() const { return mParts; }
 165
 166   const RawServoAuthorStyles* GetServoStyles() const {
 167     return mServoStyles.get();
 168   }
 169
 170   RawServoAuthorStyles* GetServoStyles() { return mServoStyles.get(); }
 171
 172   mozilla::ServoStyleRuleMap& ServoStyleRuleMap();
 173
 174   JSObject* WrapNode(JSContext*, JS::Handle<JSObject*> aGivenProto) final;
 175
 176   void NodeInfoChanged(Document* aOldDoc) override {
 177     DocumentFragment::NodeInfoChanged(aOldDoc);
 178     ClearAdoptedStyleSheets();
 179   }
 180
 181   void AddToIdTable(Element* aElement, nsAtom* aId);
 182   void RemoveFromIdTable(Element* aElement, nsAtom* aId);
 183
 184   // WebIDL methods.
 185   using mozilla::dom::DocumentOrShadowRoot::GetElementById;
 186
 187   Element* GetActiveElement();
 188
 189   /**
 190    * These methods allow UA Widget to insert DOM elements into the Shadow ROM
 191    * without putting their DOM reflectors to content scope first.
 192    * The inserted DOM will have their reflectors in the UA Widget scope.
 193    */
 194   nsINode* ImportNodeAndAppendChildAt(nsINode& aParentNode, nsINode& aNode,
 195                                       bool aDeep, mozilla::ErrorResult& rv);
 196
 197   nsINode* CreateElementAndAppendChildAt(nsINode& aParentNode,
 198                                          const nsAString& aTagName,
 199                                          mozilla::ErrorResult& rv);
 200
 201   bool IsUAWidget() const { return mIsUAWidget; }
 202
 203   void SetIsUAWidget() {
 204     MOZ_ASSERT(!HasChildren());
 205     SetFlags(NODE_HAS_BEEN_IN_UA_WIDGET);
 206     mIsUAWidget = true;
 207   }
 208
 209   void GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
 210
 211   // nsIRadioGroupContainer
 212   NS_IMETHOD WalkRadioGroup(const nsAString& aName, nsIRadioVisitor* aVisitor,
 213                             bool aFlushContent) override {
 214     return DocumentOrShadowRoot::WalkRadioGroup(aName, aVisitor, aFlushContent);
 215   }
 216   virtual void SetCurrentRadioButton(const nsAString& aName,
 217                                      HTMLInputElement* aRadio) override {
 218     DocumentOrShadowRoot::SetCurrentRadioButton(aName, aRadio);
 219   }
 220   virtual HTMLInputElement* GetCurrentRadioButton(
 221       const nsAString& aName) override {
 222     return DocumentOrShadowRoot::GetCurrentRadioButton(aName);
 223   }
 224   NS_IMETHOD
 225   GetNextRadioButton(const nsAString& aName, const bool aPrevious,
 226                      HTMLInputElement* aFocusedRadio,
 227                      HTMLInputElement** aRadioOut) override {
 228     return DocumentOrShadowRoot::GetNextRadioButton(aName, aPrevious,
 229                                                     aFocusedRadio, aRadioOut);
 230   }
 231   virtual void AddToRadioGroup(const nsAString& aName,
 232                                HTMLInputElement* aRadio) override {
 233     DocumentOrShadowRoot::AddToRadioGroup(aName, aRadio);
 234   }
 235   virtual void RemoveFromRadioGroup(const nsAString& aName,
 236                                     HTMLInputElement* aRadio) override {
 237     DocumentOrShadowRoot::RemoveFromRadioGroup(aName, aRadio);
 238   }
 239   virtual uint32_t GetRequiredRadioCount(
 240       const nsAString& aName) const override {
 241     return DocumentOrShadowRoot::GetRequiredRadioCount(aName);
 242   }
 243   virtual void RadioRequiredWillChange(const nsAString& aName,
 244                                        bool aRequiredAdded) override {
 245     DocumentOrShadowRoot::RadioRequiredWillChange(aName, aRequiredAdded);
 246   }
 247   virtual bool GetValueMissingState(const nsAString& aName) const override {
 248     return DocumentOrShadowRoot::GetValueMissingState(aName);
 249   }
 250   virtual void SetValueMissingState(const nsAString& aName,
 251                                     bool aValue) override {
 252     return DocumentOrShadowRoot::SetValueMissingState(aName, aValue);
 253   }
 254
 255  protected:
 256   // FIXME(emilio): This will need to become more fine-grained.
 257   void ApplicableRulesChanged();
 258
 259   virtual ~ShadowRoot();
 260
 261   const ShadowRootMode mMode;
 262
 263   // The computed data from the style sheets.
 264   UniquePtr<RawServoAuthorStyles> mServoStyles;
 265   UniquePtr<mozilla::ServoStyleRuleMap> mStyleRuleMap;
 266
 267   using SlotArray = TreeOrderedArray<HTMLSlotElement>;
 268   // Map from name of slot to an array of all slots in the shadow DOM with with
 269   // the given name. The slots are stored as a weak pointer because the elements
 270   // are in the shadow tree and should be kept alive by its parent.
 271   nsClassHashtable<nsStringHashKey, SlotArray> mSlotMap;
 272
 273   // Unordered array of all elements that have a part attribute in this shadow
 274   // tree.
 275   nsTArray<const Element*> mParts;
 276
 277   bool mIsUAWidget : 1;
 278
 279   nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
 280 };
 281
 282 }  // namespace dom
 283 }  // namespace mozilla
 284
 285 #endif  // mozilla_dom_shadowroot_h__