OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserv
ed. | 2 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserv
ed. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 23 matching lines...) Expand all Loading... |
34 #include "core/HTMLNames.h" | 34 #include "core/HTMLNames.h" |
35 #include "core/dom/Element.h" | 35 #include "core/dom/Element.h" |
36 #include "core/dom/ElementTraversal.h" | 36 #include "core/dom/ElementTraversal.h" |
37 #include "core/dom/TreeScope.h" | 37 #include "core/dom/TreeScope.h" |
38 #include "core/html/HTMLMapElement.h" | 38 #include "core/html/HTMLMapElement.h" |
39 | 39 |
40 namespace blink { | 40 namespace blink { |
41 | 41 |
42 using namespace HTMLNames; | 42 using namespace HTMLNames; |
43 | 43 |
44 inline bool keyMatchesId(StringImpl* key, Element& element) | 44 inline bool keyMatchesId(const AtomicString& key, const Element& element) |
45 { | 45 { |
46 return element.getIdAttribute().impl() == key; | 46 return element.getIdAttribute() == key; |
47 } | 47 } |
48 | 48 |
49 inline bool keyMatchesMapName(StringImpl* key, Element& element) | 49 inline bool keyMatchesMapName(const AtomicString& key, const Element& element) |
50 { | 50 { |
51 return isHTMLMapElement(element) && toHTMLMapElement(element).getName().impl
() == key; | 51 return isHTMLMapElement(element) && toHTMLMapElement(element).getName() == k
ey; |
52 } | 52 } |
53 | 53 |
54 inline bool keyMatchesLowercasedMapName(StringImpl* key, Element& element) | 54 inline bool keyMatchesLowercasedMapName(const AtomicString& key, const Element&
element) |
55 { | 55 { |
56 return isHTMLMapElement(element) && toHTMLMapElement(element).getName().lowe
r().impl() == key; | 56 return isHTMLMapElement(element) && toHTMLMapElement(element).getName().lowe
r() == key; |
57 } | 57 } |
58 | 58 |
59 inline bool keyMatchesLabelForAttribute(StringImpl* key, Element& element) | 59 inline bool keyMatchesLabelForAttribute(const AtomicString& key, const Element&
element) |
60 { | 60 { |
61 return isHTMLLabelElement(element) && element.getAttribute(forAttr).impl() =
= key; | 61 return isHTMLLabelElement(element) && element.getAttribute(forAttr) == key; |
62 } | 62 } |
63 | 63 |
64 PassOwnPtrWillBeRawPtr<DocumentOrderedMap> DocumentOrderedMap::create() | 64 PassOwnPtrWillBeRawPtr<DocumentOrderedMap> DocumentOrderedMap::create() |
65 { | 65 { |
66 return adoptPtrWillBeNoop(new DocumentOrderedMap()); | 66 return adoptPtrWillBeNoop(new DocumentOrderedMap()); |
67 } | 67 } |
68 | 68 |
69 void DocumentOrderedMap::add(StringImpl* key, Element* element) | 69 void DocumentOrderedMap::add(const AtomicString& key, Element* element) |
70 { | 70 { |
71 ASSERT(key); | 71 ASSERT(key); |
72 ASSERT(element); | 72 ASSERT(element); |
73 | 73 |
74 Map::AddResult addResult = m_map.add(key, adoptPtrWillBeNoop(new MapEntry(el
ement))); | 74 Map::AddResult addResult = m_map.add(key.impl(), adoptPtrWillBeNoop(new MapE
ntry(element))); |
75 if (addResult.isNewEntry) | 75 if (addResult.isNewEntry) |
76 return; | 76 return; |
77 | 77 |
78 OwnPtrWillBeMember<MapEntry>& entry = addResult.storedValue->value; | 78 OwnPtrWillBeMember<MapEntry>& entry = addResult.storedValue->value; |
79 ASSERT(entry->count); | 79 ASSERT(entry->count); |
80 entry->element = nullptr; | 80 entry->element = nullptr; |
81 entry->count++; | 81 entry->count++; |
82 entry->orderedList.clear(); | 82 entry->orderedList.clear(); |
83 } | 83 } |
84 | 84 |
85 void DocumentOrderedMap::remove(StringImpl* key, Element* element) | 85 void DocumentOrderedMap::remove(const AtomicString& key, Element* element) |
86 { | 86 { |
87 ASSERT(key); | 87 ASSERT(key); |
88 ASSERT(element); | 88 ASSERT(element); |
89 | 89 |
90 Map::iterator it = m_map.find(key); | 90 Map::iterator it = m_map.find(key.impl()); |
91 if (it == m_map.end()) | 91 if (it == m_map.end()) |
92 return; | 92 return; |
93 | 93 |
94 OwnPtrWillBeMember<MapEntry>& entry = it->value; | 94 OwnPtrWillBeMember<MapEntry>& entry = it->value; |
95 ASSERT(entry->count); | 95 ASSERT(entry->count); |
96 if (entry->count == 1) { | 96 if (entry->count == 1) { |
97 ASSERT(!entry->element || entry->element == element); | 97 ASSERT(!entry->element || entry->element == element); |
98 m_map.remove(it); | 98 m_map.remove(it); |
99 } else { | 99 } else { |
100 if (entry->element == element) { | 100 if (entry->element == element) { |
101 ASSERT(entry->orderedList.isEmpty() || entry->orderedList.first() ==
element); | 101 ASSERT(entry->orderedList.isEmpty() || entry->orderedList.first() ==
element); |
102 entry->element = entry->orderedList.size() > 1 ? entry->orderedList[
1] : nullptr; | 102 entry->element = entry->orderedList.size() > 1 ? entry->orderedList[
1] : nullptr; |
103 } | 103 } |
104 entry->count--; | 104 entry->count--; |
105 entry->orderedList.clear(); | 105 entry->orderedList.clear(); |
106 } | 106 } |
107 } | 107 } |
108 | 108 |
109 template<bool keyMatches(StringImpl*, Element&)> | 109 template<bool keyMatches(const AtomicString&, const Element&)> |
110 inline Element* DocumentOrderedMap::get(StringImpl* key, const TreeScope* scope)
const | 110 inline Element* DocumentOrderedMap::get(const AtomicString& key, const TreeScope
* scope) const |
111 { | 111 { |
112 ASSERT(key); | 112 ASSERT(key); |
113 ASSERT(scope); | 113 ASSERT(scope); |
114 | 114 |
115 MapEntry* entry = m_map.get(key); | 115 MapEntry* entry = m_map.get(key.impl()); |
116 if (!entry) | 116 if (!entry) |
117 return 0; | 117 return 0; |
118 | 118 |
119 ASSERT(entry->count); | 119 ASSERT(entry->count); |
120 if (entry->element) | 120 if (entry->element) |
121 return entry->element; | 121 return entry->element; |
122 | 122 |
123 // We know there's at least one node that matches; iterate to find the first
one. | 123 // We know there's at least one node that matches; iterate to find the first
one. |
124 for (Element* element = ElementTraversal::firstWithin(scope->rootNode()); el
ement; element = ElementTraversal::next(*element)) { | 124 for (Element* element = ElementTraversal::firstWithin(scope->rootNode()); el
ement; element = ElementTraversal::next(*element)) { |
125 if (!keyMatches(key, *element)) | 125 if (!keyMatches(key, *element)) |
126 continue; | 126 continue; |
127 entry->element = element; | 127 entry->element = element; |
128 return element; | 128 return element; |
129 } | 129 } |
130 ASSERT_NOT_REACHED(); | 130 ASSERT_NOT_REACHED(); |
131 return 0; | 131 return 0; |
132 } | 132 } |
133 | 133 |
134 Element* DocumentOrderedMap::getElementById(StringImpl* key, const TreeScope* sc
ope) const | 134 Element* DocumentOrderedMap::getElementById(const AtomicString& key, const TreeS
cope* scope) const |
135 { | 135 { |
136 return get<keyMatchesId>(key, scope); | 136 return get<keyMatchesId>(key, scope); |
137 } | 137 } |
138 | 138 |
139 const WillBeHeapVector<RawPtrWillBeMember<Element> >& DocumentOrderedMap::getAll
ElementsById(StringImpl* key, const TreeScope* scope) const | 139 const WillBeHeapVector<RawPtrWillBeMember<Element> >& DocumentOrderedMap::getAll
ElementsById(const AtomicString& key, const TreeScope* scope) const |
140 { | 140 { |
141 ASSERT(key); | 141 ASSERT(key); |
142 ASSERT(scope); | 142 ASSERT(scope); |
143 DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapVector<RawPtrWillBeMemb
er<Element> > >, emptyVector, (adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWil
lBeMember<Element> >()))); | 143 DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapVector<RawPtrWillBeMemb
er<Element> > >, emptyVector, (adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWil
lBeMember<Element> >()))); |
144 | 144 |
145 Map::iterator it = m_map.find(key); | 145 Map::iterator it = m_map.find(key.impl()); |
146 if (it == m_map.end()) | 146 if (it == m_map.end()) |
147 return *emptyVector; | 147 return *emptyVector; |
148 | 148 |
149 OwnPtrWillBeMember<MapEntry>& entry = it->value; | 149 OwnPtrWillBeMember<MapEntry>& entry = it->value; |
150 ASSERT(entry->count); | 150 ASSERT(entry->count); |
151 | 151 |
152 if (entry->orderedList.isEmpty()) { | 152 if (entry->orderedList.isEmpty()) { |
153 entry->orderedList.reserveCapacity(entry->count); | 153 entry->orderedList.reserveCapacity(entry->count); |
154 for (Element* element = entry->element ? entry->element.get() : ElementT
raversal::firstWithin(scope->rootNode()); entry->orderedList.size() < entry->cou
nt; element = ElementTraversal::next(*element)) { | 154 for (Element* element = entry->element ? entry->element.get() : ElementT
raversal::firstWithin(scope->rootNode()); entry->orderedList.size() < entry->cou
nt; element = ElementTraversal::next(*element)) { |
155 ASSERT(element); | 155 ASSERT(element); |
156 if (!keyMatchesId(key, *element)) | 156 if (!keyMatchesId(key, *element)) |
157 continue; | 157 continue; |
158 entry->orderedList.uncheckedAppend(element); | 158 entry->orderedList.uncheckedAppend(element); |
159 } | 159 } |
160 if (!entry->element) | 160 if (!entry->element) |
161 entry->element = entry->orderedList.first(); | 161 entry->element = entry->orderedList.first(); |
162 } | 162 } |
163 | 163 |
164 return entry->orderedList; | 164 return entry->orderedList; |
165 } | 165 } |
166 | 166 |
167 Element* DocumentOrderedMap::getElementByMapName(StringImpl* key, const TreeScop
e* scope) const | 167 Element* DocumentOrderedMap::getElementByMapName(const AtomicString& key, const
TreeScope* scope) const |
168 { | 168 { |
169 return get<keyMatchesMapName>(key, scope); | 169 return get<keyMatchesMapName>(key, scope); |
170 } | 170 } |
171 | 171 |
172 Element* DocumentOrderedMap::getElementByLowercasedMapName(StringImpl* key, cons
t TreeScope* scope) const | 172 Element* DocumentOrderedMap::getElementByLowercasedMapName(const AtomicString& k
ey, const TreeScope* scope) const |
173 { | 173 { |
174 return get<keyMatchesLowercasedMapName>(key, scope); | 174 return get<keyMatchesLowercasedMapName>(key, scope); |
175 } | 175 } |
176 | 176 |
177 Element* DocumentOrderedMap::getElementByLabelForAttribute(StringImpl* key, cons
t TreeScope* scope) const | 177 Element* DocumentOrderedMap::getElementByLabelForAttribute(const AtomicString& k
ey, const TreeScope* scope) const |
178 { | 178 { |
179 return get<keyMatchesLabelForAttribute>(key, scope); | 179 return get<keyMatchesLabelForAttribute>(key, scope); |
180 } | 180 } |
181 | 181 |
182 void DocumentOrderedMap::trace(Visitor* visitor) | 182 void DocumentOrderedMap::trace(Visitor* visitor) |
183 { | 183 { |
184 #if ENABLE(OILPAN) | 184 #if ENABLE(OILPAN) |
185 visitor->trace(m_map); | 185 visitor->trace(m_map); |
186 #endif | 186 #endif |
187 } | 187 } |
188 | 188 |
189 void DocumentOrderedMap::MapEntry::trace(Visitor* visitor) | 189 void DocumentOrderedMap::MapEntry::trace(Visitor* visitor) |
190 { | 190 { |
191 visitor->trace(element); | 191 visitor->trace(element); |
192 #if ENABLE(OILPAN) | 192 #if ENABLE(OILPAN) |
193 visitor->trace(orderedList); | 193 visitor->trace(orderedList); |
194 #endif | 194 #endif |
195 } | 195 } |
196 | 196 |
197 } // namespace blink | 197 } // namespace blink |
OLD | NEW |