Refactor ShadowRoot exception handling
[WebKit-https.git] / Source / WebCore / dom / ShadowRoot.h
1 /*
2  * Copyright (C) 2011 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 ShadowRoot_h
28 #define ShadowRoot_h
29
30 #include "ContainerNode.h"
31 #include "Document.h"
32 #include "DocumentFragment.h"
33 #include "Element.h"
34 #include "ExceptionCode.h"
35 #include "TreeScope.h"
36 #include <wtf/DoublyLinkedList.h>
37
38 namespace WebCore {
39
40 class Document;
41 class DOMSelection;
42 class ElementShadow;
43 class InsertionPoint;
44 class ScopeContentDistribution;
45
46 class ShadowRoot : public DocumentFragment, public TreeScope, public DoublyLinkedListNode<ShadowRoot> {
47     friend class WTF::DoublyLinkedListNode<ShadowRoot>;
48 public:
49     // FIXME: We will support multiple shadow subtrees, however current implementation does not work well
50     // if a shadow root is dynamically created. So we prohibit multiple shadow subtrees
51     // in several elements for a while.
52     // See https://bugs.webkit.org/show_bug.cgi?id=77503 and related bugs.
53     enum ShadowRootType {
54         UserAgentShadowRoot = 0,
55         AuthorShadowRoot
56     };
57     static PassRefPtr<ShadowRoot> create(Element*, ShadowRootType);
58
59     void recalcStyle(StyleChange);
60
61     virtual bool applyAuthorStyles() const OVERRIDE;
62     void setApplyAuthorStyles(bool);
63     virtual bool resetStyleInheritance() const OVERRIDE;
64     void setResetStyleInheritance(bool);
65
66     Element* host() const;
67     void setHost(Element*);
68     ElementShadow* owner() const;
69
70     String innerHTML() const;
71     void setInnerHTML(const String&, ExceptionCode&);
72
73     Element* activeElement() const;
74
75     ShadowRoot* youngerShadowRoot() const { return prev(); }
76     ShadowRoot* olderShadowRoot() const { return next(); }
77
78     bool isYoungest() const { return !youngerShadowRoot(); }
79     bool isOldest() const { return !olderShadowRoot(); }
80
81     virtual void attach();
82
83     virtual InsertionNotificationRequest insertedInto(ContainerNode*) OVERRIDE;
84     virtual void removedFrom(ContainerNode*) OVERRIDE;
85
86     virtual void registerScopedHTMLStyleChild() OVERRIDE;
87     virtual void unregisterScopedHTMLStyleChild() OVERRIDE;
88
89     ScopeContentDistribution* scopeDistribution() { return m_scopeDistribution.get(); }
90     const ScopeContentDistribution* scopeDistribution() const { return m_scopeDistribution.get(); }
91     ScopeContentDistribution* ensureScopeDistribution();
92
93     ShadowRootType type() const { return static_cast<ShadowRootType>(m_type); }
94
95     PassRefPtr<Node> cloneNode(bool, ExceptionCode&);
96
97     virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
98
99 private:
100     ShadowRoot(Document*, ShadowRootType);
101     virtual ~ShadowRoot();
102     virtual PassRefPtr<Node> cloneNode(bool deep);
103     virtual bool childTypeAllowed(NodeType) const;
104     virtual void childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta) OVERRIDE;
105
106     ShadowRoot* m_prev;
107     ShadowRoot* m_next;
108     OwnPtr<ScopeContentDistribution> m_scopeDistribution;
109     unsigned m_numberOfStyles : 28;
110     unsigned m_applyAuthorStyles : 1;
111     unsigned m_resetStyleInheritance : 1;
112     unsigned m_type : 1;
113     unsigned m_registeredWithParentShadowRoot : 1;
114 };
115
116 inline Element* ShadowRoot::host() const
117 {
118     return toElement(parentOrHostNode());
119 }
120
121 inline void ShadowRoot::setHost(Element* host)
122 {
123     setParentOrHostNode(host);
124 }
125
126 inline Element* ShadowRoot::activeElement() const
127 {
128     if (Node* node = treeScope()->focusedNode())
129         return node->isElementNode() ? toElement(node) : 0;
130     return 0;
131 }
132
133 inline const ShadowRoot* toShadowRoot(const Node* node)
134 {
135     ASSERT(!node || node->isShadowRoot());
136     return static_cast<const ShadowRoot*>(node);
137 }
138
139 inline ShadowRoot* toShadowRoot(Node* node)
140 {
141     return const_cast<ShadowRoot*>(toShadowRoot(static_cast<const Node*>(node)));
142 }
143
144 } // namespace
145
146 #endif