1 files changed, 34 insertions, 82 deletions

diff --git a/Source/WebCore/dom/TreeScope.h b/Source/WebCore/dom/TreeScope.h
index 4264d74f7..954ec718b 100644
--- a/Source/WebCore/dom/TreeScope.h
+++ b/Source/WebCore/dom/TreeScope.h
@@ -24,17 +24,16 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef TreeScope_h
-#define TreeScope_h
+#pragma once
 
 #include "DocumentOrderedMap.h"
+#include <memory>
 #include <wtf/Forward.h>
 #include <wtf/text/AtomicString.h>
 
 namespace WebCore {
 
 class ContainerNode;
-class DOMSelection;
 class Document;
 class Element;
 class HTMLLabelElement;
@@ -42,49 +41,53 @@ class HTMLMapElement;
 class LayoutPoint;
 class IdTargetObserverRegistry;
 class Node;
+class ShadowRoot;
 
-// A class which inherits both Node and TreeScope must call clearRareData() in its destructor
-// so that the Node destructor no longer does problematic NodeList cache manipulation in
-// the destructor.
 class TreeScope {
     friend class Document;
     friend class TreeScopeAdopter;
 
 public:
     TreeScope* parentTreeScope() const { return m_parentTreeScope; }
-    void setParentTreeScope(TreeScope*);
+    void setParentTreeScope(TreeScope&);
 
-    Element* focusedElement();
-    Element* getElementById(const AtomicString&) const;
+    Element* focusedElementInScope();
+    Element* pointerLockElement() const;
+
+    WEBCORE_EXPORT Element* getElementById(const AtomicString&) const;
+    WEBCORE_EXPORT Element* getElementById(const String&) const;
     const Vector<Element*>* getAllElementsById(const AtomicString&) const;
     bool hasElementWithId(const AtomicStringImpl&) const;
     bool containsMultipleElementsWithId(const AtomicString& id) const;
     void addElementById(const AtomicStringImpl& elementId, Element&, bool notifyObservers = true);
     void removeElementById(const AtomicStringImpl& elementId, Element&, bool notifyObservers = true);
 
-    Element* getElementByName(const AtomicString&) const;
+    WEBCORE_EXPORT Element* getElementByName(const AtomicString&) const;
     bool hasElementWithName(const AtomicStringImpl&) const;
     bool containsMultipleElementsWithName(const AtomicString&) const;
     void addElementByName(const AtomicStringImpl&, Element&);
     void removeElementByName(const AtomicStringImpl&, Element&);
 
-    Document* documentScope() const { return m_documentScope; }
+    Document& documentScope() const { return m_documentScope.get(); }
+    static ptrdiff_t documentScopeMemoryOffset() { return OBJECT_OFFSETOF(TreeScope, m_documentScope); }
+
+    // https://dom.spec.whatwg.org/#retarget
+    Node& retargetToScope(Node&) const;
 
-    Node* ancestorInThisScope(Node*) const;
+    Node* ancestorNodeInThisScope(Node*) const;
+    WEBCORE_EXPORT Element* ancestorElementInThisScope(Element*) const;
 
     void addImageMap(HTMLMapElement&);
     void removeImageMap(HTMLMapElement&);
     HTMLMapElement* getImageMap(const String& url) const;
 
-    Element* elementFromPoint(int x, int y) const;
-
     // For accessibility.
-    bool shouldCacheLabelsByForAttribute() const { return m_labelsByForAttribute; }
+    bool shouldCacheLabelsByForAttribute() const { return !!m_labelsByForAttribute; }
     void addLabel(const AtomicStringImpl& forAttributeValue, HTMLLabelElement&);
     void removeLabel(const AtomicStringImpl& forAttributeValue, HTMLLabelElement&);
     HTMLLabelElement* labelElementForId(const AtomicString& forAttributeValue);
 
-    DOMSelection* getSelection() const;
+    WEBCORE_EXPORT Element* elementFromPoint(double x, double y);
 
     // Find first anchor with the given name.
     // First searches for an element with the given ID, but if that fails, then looks
@@ -93,85 +96,37 @@ public:
     // quirks mode for historical compatibility reasons.
     Element* findAnchor(const String& name);
 
-    virtual bool applyAuthorStyles() const;
-
     // Used by the basic DOM mutation methods (e.g., appendChild()).
-    void adoptIfNeeded(Node*);
+    void adoptIfNeeded(Node&);
 
-    ContainerNode* rootNode() const { return m_rootNode; }
+    ContainerNode& rootNode() const { return m_rootNode; }
 
     IdTargetObserverRegistry& idTargetObserverRegistry() const { return *m_idTargetObserverRegistry.get(); }
 
-    static TreeScope& noDocumentInstance()
-    {
-        DEFINE_STATIC_LOCAL(TreeScope, instance, ());
-        return instance;
-    }
-
-    // Nodes belonging to this scope hold self-only references -
-    // these are enough to keep the scope from being destroyed, but
-    // not enough to keep it from removing its children. This allows a
-    // node that outlives its scope to still have a valid document
-    // pointer without introducing reference cycles.
-    void selfOnlyRef()
-    {
-        ASSERT(!deletionHasBegun());
-        ++m_selfOnlyRefCount;
-    }
-
-    void selfOnlyDeref()
-    {
-        ASSERT(!deletionHasBegun());
-        --m_selfOnlyRefCount;
-        if (!m_selfOnlyRefCount && !refCount() && this != &noDocumentInstance()) {
-            beginDeletion();
-            delete this;
-        }
-    }
-
-    void removedLastRefToScope();
-
 protected:
-    TreeScope(ContainerNode*, Document*);
-    explicit TreeScope(Document*);
-    virtual ~TreeScope();
+    TreeScope(ShadowRoot&, Document&);
+    explicit TreeScope(Document&);
+    ~TreeScope();
 
     void destroyTreeScopeData();
-    void clearDocumentScope();
-    void setDocumentScope(Document* document)
+    void setDocumentScope(Document& document)
     {
-        ASSERT(document);
-        ASSERT(this != &noDocumentInstance());
         m_documentScope = document;
     }
 
-private:
-    TreeScope();
-
-    virtual void dropChildren() { }
-
-    int refCount() const;
-#ifndef NDEBUG
-    bool deletionHasBegun();
-    void beginDeletion();
-#else
-    bool deletionHasBegun() { return false; }
-    void beginDeletion() { }
-#endif
+    Node* nodeFromPoint(const LayoutPoint& clientPoint, LayoutPoint* localPoint);
 
-    ContainerNode* m_rootNode;
-    Document* m_documentScope;
+private:
+    ContainerNode& m_rootNode;
+    std::reference_wrapper<Document> m_documentScope;
     TreeScope* m_parentTreeScope;
-    unsigned m_selfOnlyRefCount;
 
-    OwnPtr<DocumentOrderedMap> m_elementsById;
-    OwnPtr<DocumentOrderedMap> m_elementsByName;
-    OwnPtr<DocumentOrderedMap> m_imageMapsByName;
-    OwnPtr<DocumentOrderedMap> m_labelsByForAttribute;
+    std::unique_ptr<DocumentOrderedMap> m_elementsById;
+    std::unique_ptr<DocumentOrderedMap> m_elementsByName;
+    std::unique_ptr<DocumentOrderedMap> m_imageMapsByName;
+    std::unique_ptr<DocumentOrderedMap> m_labelsByForAttribute;
 
-    OwnPtr<IdTargetObserverRegistry> m_idTargetObserverRegistry;
-
-    mutable RefPtr<DOMSelection> m_selection;
+    std::unique_ptr<IdTargetObserverRegistry> m_idTargetObserverRegistry;
 };
 
 inline bool TreeScope::hasElementWithId(const AtomicStringImpl& id) const
@@ -194,9 +149,6 @@ inline bool TreeScope::containsMultipleElementsWithName(const AtomicString& name
     return m_elementsByName && name.impl() && m_elementsByName->containsMultiple(*name.impl());
 }
 
-Node* nodeFromPoint(Document*, int x, int y, LayoutPoint* localPoint = 0);
 TreeScope* commonTreeScope(Node*, Node*);
 
 } // namespace WebCore
-
-#endif // TreeScope_h