Changing id, className, or attribute should invalidate distribution
[WebKit-https.git] / Source / WebCore / html / shadow / InsertionPoint.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  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef InsertionPoint_h
32 #define InsertionPoint_h
33
34 #include "CSSSelectorList.h"
35 #include "ContentDistributor.h"
36 #include "ElementShadow.h"
37 #include "HTMLElement.h"
38 #include "HTMLNames.h"
39 #include "ShadowRoot.h"
40 #include <wtf/Forward.h>
41
42 namespace WebCore {
43
44 class InsertionPoint : public HTMLElement {
45 public:
46     virtual ~InsertionPoint();
47
48     bool hasDistribution() const { return !m_distribution.isEmpty(); }
49     void setDistribution(ContentDistribution& distribution) { m_distribution.swap(distribution); }
50     void clearDistribution() { m_distribution.clear(); }
51     bool isShadowBoundary() const;
52     bool isActive() const;
53
54     PassRefPtr<NodeList> getDistributedNodes() const;
55
56     virtual const AtomicString& select() const = 0;
57     virtual bool isSelectValid() = 0;
58     virtual const CSSSelectorList& selectorList() = 0;
59
60     bool resetStyleInheritance() const;
61     void setResetStyleInheritance(bool);
62
63     virtual void attach();
64     virtual void detach();
65
66     bool shouldUseFallbackElements() const;
67
68     size_t indexOf(Node* node) const { return m_distribution.find(node); }
69     bool contains(const Node* node) const { return m_distribution.contains(const_cast<Node*>(node)) || (node->isShadowRoot() && toShadowRoot(node)->assignedTo() == this); }
70     size_t size() const { return m_distribution.size(); }
71     Node* at(size_t index)  const { return m_distribution.at(index).get(); }
72     Node* first() const { return m_distribution.isEmpty() ? 0 : m_distribution.first().get(); }
73     Node* last() const { return m_distribution.isEmpty() ? 0 : m_distribution.last().get(); }
74     Node* nextTo(const Node*) const;
75     Node* previousTo(const Node*) const;
76
77 protected:
78     InsertionPoint(const QualifiedName&, Document*);
79     virtual bool rendererIsNeeded(const NodeRenderingContext&) OVERRIDE;
80     virtual void childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta) OVERRIDE;
81     virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
82     virtual void removedFrom(ContainerNode*) OVERRIDE;
83
84 private:
85     ContentDistribution m_distribution;
86     bool m_shouldResetStyleInheritance : 1;
87 };
88
89 inline bool isInsertionPoint(const Node* node)
90 {
91     ASSERT(node);
92     return node->isInsertionPoint();
93 }
94
95 inline InsertionPoint* toInsertionPoint(Node* node)
96 {
97     ASSERT(!node || isInsertionPoint(node));
98     return static_cast<InsertionPoint*>(node);
99 }
100
101 inline const InsertionPoint* toInsertionPoint(const Node* node)
102 {
103     ASSERT(!node || isInsertionPoint(node));
104     return static_cast<const InsertionPoint*>(node);
105 }
106
107 inline bool isActiveInsertionPoint(const Node* node)
108 {
109     return isInsertionPoint(node) && toInsertionPoint(node)->isActive();
110 }
111
112 inline bool isLowerEncapsulationBoundary(Node* node)
113 {
114     if (!node || !isInsertionPoint(node))
115         return false;
116     return toInsertionPoint(node)->isShadowBoundary();
117 }
118
119 inline Node* parentNodeForDistribution(const Node* node)
120 {
121     ASSERT(node);
122
123     if (Node* parent = node->parentNode()) {
124         if (isInsertionPoint(parent) && toInsertionPoint(parent)->shouldUseFallbackElements())
125             return parent->parentNode();
126         return parent;
127     }
128
129     return 0;
130 }
131
132 inline Element* parentElementForDistribution(const Node* node)
133 {
134     if (Node* parent = parentNodeForDistribution(node)) {
135         if (parent->isElementNode())
136             return toElement(parent);
137     }
138
139     return 0;
140 }
141
142 inline ElementShadow* shadowOfParentForDistribution(const Node* node)
143 {
144     ASSERT(node);
145     if (Element* parent = parentElementForDistribution(node))
146         return parent->shadow();
147
148     return 0;
149 }
150
151 inline InsertionPoint* resolveReprojection(const Node* projectedNode)
152 {
153     InsertionPoint* insertionPoint = 0;
154     const Node* current = projectedNode;
155
156     while (current) {
157         if (ElementShadow* shadow = shadowOfParentForDistribution(current)) {
158             shadow->ensureDistribution();
159             if (InsertionPoint* insertedTo = shadow->distributor().findInsertionPointFor(projectedNode)) {
160                 current = insertedTo;
161                 insertionPoint = insertedTo;
162                 continue;
163             }
164         }
165
166         if (Node* parent = parentNodeForDistribution(current)) {
167             if (InsertionPoint* insertedTo = parent->isShadowRoot() ? toShadowRoot(parent)->assignedTo() : 0) {
168                 current = insertedTo;
169                 insertionPoint = insertedTo;
170                 continue;
171             }
172         }
173
174         break;
175     }
176
177     return insertionPoint;
178 }
179
180 } // namespace WebCore
181
182 #endif // InsertionPoint_h