Refactor ShadowRoot exception handling
[WebKit-https.git] / Source / WebCore / dom / ElementShadow.h
1 /*
2  * Copyright (C) 2012 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Neither the name of Google Inc. nor the names of its
11  * contributors may be used to endorse or promote products derived from
12  * this software without specific prior written permission.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
15  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
16  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
18  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
20  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef ElementShadow_h
28 #define ElementShadow_h
29
30 #include "ContentDistributor.h"
31 #include "ExceptionCode.h"
32 #include "ShadowRoot.h"
33 #include <wtf/DoublyLinkedList.h>
34 #include <wtf/Noncopyable.h>
35 #include <wtf/PassOwnPtr.h>
36 #include <wtf/PassRefPtr.h>
37 #include <wtf/Vector.h>
38
39 namespace WebCore {
40
41 class ElementShadow {
42    WTF_MAKE_NONCOPYABLE(ElementShadow); WTF_MAKE_FAST_ALLOCATED;
43 public:
44     static PassOwnPtr<ElementShadow> create()
45     {
46         return adoptPtr(new ElementShadow());
47     }
48
49     ~ElementShadow()
50     {
51         removeAllShadowRoots();
52     }
53
54     Element* host() const;
55     ShadowRoot* youngestShadowRoot() const { return m_shadowRoots.head(); }
56     ShadowRoot* oldestShadowRoot() const { return m_shadowRoots.tail(); }
57     ElementShadow* containingShadow() const;
58
59     void addShadowRoot(Element* shadowHost, PassRefPtr<ShadowRoot>, ShadowRoot::ShadowRootType);
60
61     void attach();
62     void detach();
63
64     bool childNeedsStyleRecalc() const;
65     bool needsStyleRecalc() const;
66     void recalcStyle(Node::StyleChange);
67
68     void invalidateDistribution() { m_distributor.invalidateDistribution(host()); }
69     void didAffectSelector(AffectedSelectorMask mask) { m_distributor.didAffectSelector(host(), mask); }
70     void willAffectSelector() { m_distributor.willAffectSelector(host()); }
71
72     ContentDistributor& distributor() { return m_distributor; }
73     const ContentDistributor& distributor() const { return m_distributor; }
74
75     void reportMemoryUsage(MemoryObjectInfo*) const;
76
77 private:
78     ElementShadow() { }
79
80     void removeAllShadowRoots();
81
82     DoublyLinkedList<ShadowRoot> m_shadowRoots;
83     ContentDistributor m_distributor;
84 };
85
86 inline Element* ElementShadow::host() const
87 {
88     ASSERT(!m_shadowRoots.isEmpty());
89     return youngestShadowRoot()->host();
90 }
91
92 inline ShadowRoot* Node::youngestShadowRoot() const
93 {
94     if (!this->isElementNode())
95         return 0;
96     if (ElementShadow* shadow = toElement(this)->shadow())
97         return shadow->youngestShadowRoot();
98     return 0;
99 }
100
101 inline ElementShadow* ElementShadow::containingShadow() const
102 {
103     if (ShadowRoot* parentRoot = host()->containingShadowRoot())
104         return parentRoot->owner();
105     return 0;
106 }
107
108 class ShadowRootVector : public Vector<RefPtr<ShadowRoot> > {
109 public:
110     explicit ShadowRootVector(ElementShadow* tree)
111     {
112         for (ShadowRoot* root = tree->youngestShadowRoot(); root; root = root->olderShadowRoot())
113             append(root);
114     }
115 };
116
117 inline ElementShadow* shadowOfParent(const Node* node)
118 {
119     if (!node)
120         return 0;
121     if (Node* parent = node->parentNode())
122         if (parent->isElementNode())
123             return toElement(parent)->shadow();
124     return 0;
125 }
126
127
128 } // namespace
129
130 #endif