OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef NthIndexCache_h | 5 #ifndef NthIndexCache_h |
6 #define NthIndexCache_h | 6 #define NthIndexCache_h |
7 | 7 |
8 #include "core/CoreExport.h" | 8 #include "core/CoreExport.h" |
9 #include "core/dom/Element.h" | 9 #include "core/dom/Element.h" |
10 #include "core/dom/ElementTraversal.h" | 10 #include "core/dom/ElementTraversal.h" |
11 #include "platform/heap/Handle.h" | 11 #include "platform/heap/Handle.h" |
12 #include "wtf/HashMap.h" | 12 #include "wtf/HashMap.h" |
13 #include "wtf/OwnPtr.h" | 13 #include "wtf/OwnPtr.h" |
14 #include "wtf/RefPtr.h" | 14 #include "wtf/RefPtr.h" |
15 | 15 |
16 namespace blink { | 16 namespace blink { |
17 | 17 |
18 class Document; | 18 class Document; |
| 19 class HasTagName { |
| 20 public: |
| 21 explicit HasTagName(const QualifiedName& tagName) : m_tagName(tagName) { } |
| 22 bool operator() (const Element& element) const { return element.hasTagName(m
_tagName); } |
| 23 private: |
| 24 const QualifiedName m_tagName; |
| 25 }; |
19 | 26 |
20 class CORE_EXPORT NthIndexCache final { | 27 class CORE_EXPORT NthIndexCache final { |
21 STACK_ALLOCATED(); | 28 STACK_ALLOCATED(); |
22 WTF_MAKE_NONCOPYABLE(NthIndexCache); | 29 WTF_MAKE_NONCOPYABLE(NthIndexCache); |
23 public: | 30 public: |
24 explicit NthIndexCache(Document&); | 31 explicit NthIndexCache(Document&); |
25 ~NthIndexCache(); | 32 ~NthIndexCache(); |
26 | 33 |
27 inline unsigned nthChildIndex(Element&); | 34 inline unsigned nthChildIndex(Element&); |
| 35 inline unsigned nthChildIndexOfType(Element&, const QualifiedName&); |
28 inline unsigned nthLastChildIndex(Element&); | 36 inline unsigned nthLastChildIndex(Element&); |
| 37 inline unsigned nthLastChildIndexOfType(Element&, const QualifiedName&); |
29 | 38 |
30 private: | 39 private: |
31 class NthIndexData final : public NoBaseWillBeGarbageCollected<NthIndexData>
{ | 40 class NthIndexData final : public NoBaseWillBeGarbageCollected<NthIndexData>
{ |
32 WTF_MAKE_NONCOPYABLE(NthIndexData); | 41 WTF_MAKE_NONCOPYABLE(NthIndexData); |
33 DECLARE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(NthIndexData); | 42 DECLARE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(NthIndexData); |
34 public: | 43 public: |
35 NthIndexData() { } | 44 NthIndexData() { } |
36 | 45 |
37 inline unsigned nthIndex(Element&); | 46 inline unsigned nthIndex(Element&); |
| 47 inline unsigned nthIndexOfType(Element&, const QualifiedName&); |
38 inline unsigned nthLastIndex(Element&); | 48 inline unsigned nthLastIndex(Element&); |
| 49 inline unsigned nthLastIndexOfType(Element&, const QualifiedName&); |
39 | 50 |
40 unsigned cacheNthIndices(Element&); | 51 unsigned cacheNthIndices(Element&); |
| 52 unsigned cacheNthIndicesOfType(Element&, const QualifiedName&); |
41 | 53 |
42 WillBeHeapHashMap<RawPtrWillBeMember<Element>, unsigned> m_elementIndexM
ap; | 54 WillBeHeapHashMap<RawPtrWillBeMember<Element>, unsigned> m_elementIndexM
ap; |
43 unsigned m_count = 0; | 55 unsigned m_count = 0; |
44 | 56 |
45 DECLARE_TRACE(); | 57 DECLARE_TRACE(); |
46 }; | 58 }; |
47 | 59 |
| 60 using ParentMap = WillBeHeapHashMap<RefPtrWillBeMember<Node>, OwnPtrWillBeMe
mber<NthIndexData>>; |
| 61 OwnPtrWillBeMember<ParentMap> m_parentMap; |
| 62 |
| 63 using IndexByType = WillBeHeapHashMap<String, OwnPtrWillBeMember<NthIndexDat
a>>; |
| 64 OwnPtrWillBeMember<IndexByType> m_IndexByType; |
| 65 |
| 66 using ParentMapForType = WillBeHeapHashMap<RefPtrWillBeMember<Node>, OwnPtrW
illBeMember<IndexByType>>; |
| 67 OwnPtrWillBeMember<ParentMapForType> m_parentMapForType; |
| 68 |
| 69 |
48 NthIndexData& ensureNthIndexDataFor(Node&); | 70 NthIndexData& ensureNthIndexDataFor(Node&); |
| 71 NthIndexCache::IndexByType& ensureTypeIndexMap(Node&); |
49 | 72 |
50 using ParentMap = WillBeHeapHashMap<RefPtrWillBeMember<Node>, OwnPtrWillBeMe
mber<NthIndexData>>; | 73 NthIndexCache::NthIndexData& nthIndexDataWithTagName(Element&); |
51 | 74 |
52 OwnPtrWillBeMember<ParentMap> m_parentMap; | |
53 RawPtrWillBeMember<Document> m_document; | 75 RawPtrWillBeMember<Document> m_document; |
54 uint64_t m_domTreeVersion; | 76 uint64_t m_domTreeVersion; |
55 }; | 77 }; |
56 | 78 |
57 inline unsigned NthIndexCache::NthIndexData::nthIndex(Element& element) | 79 inline unsigned NthIndexCache::NthIndexData::nthIndex(Element& element) |
58 { | 80 { |
59 if (element.isPseudoElement()) | 81 if (element.isPseudoElement()) |
60 return 1; | 82 return 1; |
61 if (!m_count) | 83 if (!m_count) |
62 return cacheNthIndices(element); | 84 return cacheNthIndices(element); |
63 | 85 |
64 unsigned index = 0; | 86 unsigned index = 0; |
65 for (Element* sibling = &element; sibling; sibling = ElementTraversal::previ
ousSibling(*sibling), index++) { | 87 for (Element* sibling = &element; sibling; sibling = ElementTraversal::previ
ousSibling(*sibling), index++) { |
66 auto it = m_elementIndexMap.find(sibling); | 88 auto it = m_elementIndexMap.find(sibling); |
67 if (it != m_elementIndexMap.end()) | 89 if (it != m_elementIndexMap.end()) |
68 return it->value + index; | 90 return it->value + index; |
69 } | 91 } |
70 return index; | 92 return index; |
71 } | 93 } |
72 | 94 |
| 95 inline unsigned NthIndexCache::NthIndexData::nthIndexOfType(Element& element, co
nst QualifiedName& type) |
| 96 { |
| 97 if (element.isPseudoElement()) |
| 98 return 1; |
| 99 if (!m_count) |
| 100 return cacheNthIndicesOfType(element, type); |
| 101 unsigned index = 0; |
| 102 for (Element* sibling = &element; sibling; sibling = ElementTraversal::previ
ousSibling(*sibling, HasTagName(type)), index++) { |
| 103 auto it = m_elementIndexMap.find(sibling); |
| 104 if (it != m_elementIndexMap.end()) |
| 105 return it->value + index; |
| 106 } |
| 107 return index; |
| 108 } |
| 109 |
73 inline unsigned NthIndexCache::NthIndexData::nthLastIndex(Element& element) | 110 inline unsigned NthIndexCache::NthIndexData::nthLastIndex(Element& element) |
74 { | 111 { |
75 if (element.isPseudoElement()) | 112 if (element.isPseudoElement()) |
76 return 1; | 113 return 1; |
77 unsigned index = nthIndex(element); | 114 unsigned index = nthIndex(element); |
78 return m_count - index + 1; | 115 return m_count - index + 1; |
79 } | 116 } |
80 | 117 |
| 118 inline unsigned NthIndexCache::NthIndexData::nthLastIndexOfType(Element& element
, const QualifiedName& type) |
| 119 { |
| 120 if (element.isPseudoElement()) |
| 121 return 1; |
| 122 unsigned index = nthIndexOfType(element, type); |
| 123 return m_count - index + 1; |
| 124 } |
| 125 |
81 inline unsigned NthIndexCache::nthChildIndex(Element& element) | 126 inline unsigned NthIndexCache::nthChildIndex(Element& element) |
82 { | 127 { |
83 ASSERT(element.parentNode()); | 128 ASSERT(element.parentNode()); |
84 return ensureNthIndexDataFor(*element.parentNode()).nthIndex(element); | 129 return ensureNthIndexDataFor(*element.parentNode()).nthIndex(element); |
85 } | 130 } |
86 | 131 |
| 132 inline unsigned NthIndexCache::nthChildIndexOfType(Element& element, const Quali
fiedName& type) |
| 133 { |
| 134 ASSERT(element.parentNode()); |
| 135 return nthIndexDataWithTagName(element).nthIndexOfType(element, type); |
| 136 } |
| 137 |
87 inline unsigned NthIndexCache::nthLastChildIndex(Element& element) | 138 inline unsigned NthIndexCache::nthLastChildIndex(Element& element) |
88 { | 139 { |
89 ASSERT(element.parentNode()); | 140 ASSERT(element.parentNode()); |
90 return ensureNthIndexDataFor(*element.parentNode()).nthLastIndex(element); | 141 return ensureNthIndexDataFor(*element.parentNode()).nthLastIndex(element); |
91 } | 142 } |
92 | 143 |
| 144 inline unsigned NthIndexCache::nthLastChildIndexOfType(Element& element, const Q
ualifiedName& type) |
| 145 { |
| 146 ASSERT(element.parentNode()); |
| 147 return nthIndexDataWithTagName(element).nthLastIndexOfType(element, type); |
| 148 } |
| 149 |
| 150 |
93 } // namespace blink | 151 } // namespace blink |
94 | 152 |
95 #endif // NthIndexCache_h | 153 #endif // NthIndexCache_h |
OLD | NEW |