1 /* 2 * Copyright (C) 1999 Lars Knoll (knoll (at) kde.org) 3 * (C) 1999 Antti Koivisto (koivisto (at) kde.org) 4 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved. 5 * Copyright (C) 2014 Samsung Electronics. All rights reserved. 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Library General Public 9 * License as published by the Free Software Foundation; either 10 * version 2 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Library General Public License for more details. 16 * 17 * You should have received a copy of the GNU Library General Public License 18 * along with this library; see the file COPYING.LIB. If not, write to 19 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 20 * Boston, MA 02110-1301, USA. 21 * 22 */ 23 24 #ifndef HTMLCollection_h 25 #define HTMLCollection_h 26 27 #include "core/dom/LiveNodeListBase.h" 28 #include "core/html/CollectionIndexCache.h" 29 #include "core/html/CollectionType.h" 30 #include "wtf/Forward.h" 31 #include "wtf/HashMap.h" 32 #include "wtf/Vector.h" 33 34 namespace WebCore { 35 36 class HTMLCollection : public RefCountedWillBeGarbageCollectedFinalized<HTMLCollection>, public ScriptWrappable, public LiveNodeListBase { 37 WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(HTMLCollection); 38 public: 39 enum ItemAfterOverrideType { 40 OverridesItemAfter, 41 DoesNotOverrideItemAfter, 42 }; 43 44 static PassRefPtrWillBeRawPtr<HTMLCollection> create(ContainerNode& base, CollectionType); 45 virtual ~HTMLCollection(); 46 virtual void invalidateCache(Document* oldDocument = 0) const OVERRIDE; 47 void invalidateCacheForAttribute(const QualifiedName*) const; 48 49 // DOM API 50 unsigned length() const { return m_collectionIndexCache.nodeCount(*this); } 51 Element* item(unsigned offset) const { return m_collectionIndexCache.nodeAt(*this, offset); } 52 virtual Element* namedItem(const AtomicString& name) const; 53 bool namedPropertyQuery(const AtomicString&, ExceptionState&); 54 void namedPropertyEnumerator(Vector<String>& names, ExceptionState&); 55 56 // Non-DOM API 57 void namedItems(const AtomicString& name, WillBeHeapVector<RefPtrWillBeMember<Element> >&) const; 58 bool isEmpty() const { return m_collectionIndexCache.isEmpty(*this); } 59 bool hasExactlyOneItem() const { return m_collectionIndexCache.hasExactlyOneNode(*this); } 60 61 // CollectionIndexCache API. 62 bool canTraverseBackward() const { return !overridesItemAfter(); } 63 Element* traverseToFirstElement() const; 64 Element* traverseToLastElement() const; 65 Element* traverseForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset) const; 66 Element* traverseBackwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset) const; 67 68 virtual void trace(Visitor*); 69 70 protected: 71 HTMLCollection(ContainerNode& base, CollectionType, ItemAfterOverrideType); 72 73 class NamedItemCache FINAL : public NoBaseWillBeGarbageCollected<NamedItemCache> { 74 public: 75 static PassOwnPtrWillBeRawPtr<NamedItemCache> create() 76 { 77 return adoptPtrWillBeNoop(new NamedItemCache); 78 } 79 80 WillBeHeapVector<RawPtrWillBeMember<Element> >* getElementsById(const AtomicString& id) const { return m_idCache.get(id.impl()); } 81 WillBeHeapVector<RawPtrWillBeMember<Element> >* getElementsByName(const AtomicString& name) const { return m_nameCache.get(name.impl()); } 82 void addElementWithId(const AtomicString& id, Element* element) { addElementToMap(m_idCache, id, element); } 83 void addElementWithName(const AtomicString& name, Element* element) { addElementToMap(m_nameCache, name, element); } 84 85 void trace(Visitor* visitor) 86 { 87 visitor->trace(m_idCache); 88 visitor->trace(m_nameCache); 89 } 90 91 private: 92 NamedItemCache(); 93 typedef WillBeHeapHashMap<StringImpl*, OwnPtrWillBeMember<WillBeHeapVector<RawPtrWillBeMember<Element> > > > StringToElementsMap; 94 static void addElementToMap(StringToElementsMap& map, const AtomicString& key, Element* element) 95 { 96 OwnPtrWillBeMember<WillBeHeapVector<RawPtrWillBeMember<Element> > >& vector = map.add(key.impl(), nullptr).storedValue->value; 97 if (!vector) 98 vector = adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWillBeMember<Element> >); 99 vector->append(element); 100 } 101 102 StringToElementsMap m_idCache; 103 StringToElementsMap m_nameCache; 104 }; 105 106 bool overridesItemAfter() const { return m_overridesItemAfter; } 107 virtual Element* virtualItemAfter(Element*) const; 108 bool shouldOnlyIncludeDirectChildren() const { return m_shouldOnlyIncludeDirectChildren; } 109 virtual void supportedPropertyNames(Vector<String>& names); 110 111 virtual void updateIdNameCache() const; 112 bool hasValidIdNameCache() const { return m_namedItemCache; } 113 114 void setNamedItemCache(PassOwnPtrWillBeRawPtr<NamedItemCache> cache) const 115 { 116 ASSERT(!m_namedItemCache); 117 document().registerNodeListWithIdNameCache(this); 118 m_namedItemCache = cache; 119 } 120 121 NamedItemCache& namedItemCache() const 122 { 123 ASSERT(m_namedItemCache); 124 return *m_namedItemCache; 125 } 126 127 private: 128 void invalidateIdNameCacheMaps(Document* oldDocument = 0) const 129 { 130 if (!hasValidIdNameCache()) 131 return; 132 133 // Make sure we decrement the NodeListWithIdNameCache count from 134 // the old document instead of the new one in the case the collection 135 // is moved to a new document. 136 unregisterIdNameCacheFromDocument(oldDocument ? *oldDocument : document()); 137 138 m_namedItemCache.clear(); 139 } 140 141 void unregisterIdNameCacheFromDocument(Document& document) const 142 { 143 ASSERT(hasValidIdNameCache()); 144 document.unregisterNodeListWithIdNameCache(this); 145 } 146 147 const unsigned m_overridesItemAfter : 1; 148 const unsigned m_shouldOnlyIncludeDirectChildren : 1; 149 mutable OwnPtrWillBeMember<NamedItemCache> m_namedItemCache; 150 mutable CollectionIndexCache<HTMLCollection, Element> m_collectionIndexCache; 151 }; 152 153 DEFINE_TYPE_CASTS(HTMLCollection, LiveNodeListBase, collection, isHTMLCollectionType(collection->type()), isHTMLCollectionType(collection.type())); 154 155 inline void HTMLCollection::invalidateCacheForAttribute(const QualifiedName* attrName) const 156 { 157 if (!attrName || shouldInvalidateTypeOnAttributeChange(invalidationType(), *attrName)) 158 invalidateCache(); 159 else if (*attrName == HTMLNames::idAttr || *attrName == HTMLNames::nameAttr) 160 invalidateIdNameCacheMaps(); 161 } 162 163 } // namespace 164 165 #endif 166