Source/WebCore/html/HTMLPropertiesCollection.cpp

   1 /*
   2  * Copyright (c) 2011 Motorola Mobility, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without modification,
   5  * are permitted provided that the following conditions are met:
   6  *
   7  * Redistributions of source code must retain the above copyright notice,
   8  * this list of conditions and the following disclaimer.
   9  *
  10  * Redistributions in binary form must reproduce the above copyright notice,
  11  * this list of conditions and the following disclaimer in the documentation and/or
  12  * other materials provided with the distribution.
  13  *
  14  * Neither the name of Motorola Mobility, Inc. nor the names of its contributors may
  15  * be used to endorse or promote products derived from this software without
  16  * 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 LIMITED TO,
  20  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  21  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  22  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  25  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  26  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  27  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32
  33 #if ENABLE(MICRODATA)
  34
  35 #include "HTMLPropertiesCollection.h"
  36
  37 #include "DOMSettableTokenList.h"
  38 #include "DOMStringList.h"
  39 #include "HTMLElement.h"
  40 #include "HTMLNames.h"
  41 #include "Node.h"
  42 #include "StaticNodeList.h"
  43
  44 namespace WebCore {
  45
  46 using namespace HTMLNames;
  47
  48 PassRefPtr<HTMLPropertiesCollection> HTMLPropertiesCollection::create(Node* itemNode)
  49 {
  50     return adoptRef(new HTMLPropertiesCollection(itemNode));
  51 }
  52
  53 HTMLPropertiesCollection::HTMLPropertiesCollection(Node* itemNode)
  54     : HTMLCollection(itemNode, ItemProperties, DoNotSupportItemBefore)
  55     , m_hasPropertyNameCache(false)
  56     , m_hasItemRefElements(false)
  57 {
  58 }
  59
  60 HTMLPropertiesCollection::~HTMLPropertiesCollection()
  61 {
  62 }
  63
  64 void HTMLPropertiesCollection::updateRefElements() const
  65 {
  66     if (m_hasItemRefElements)
  67         return;
  68
  69     HTMLElement* baseElement = toHTMLElement(base());
  70
  71     m_itemRefElements.clear();
  72     m_hasItemRefElements = true;
  73
  74     if (!baseElement->fastHasAttribute(itemscopeAttr))
  75         return;
  76
  77     if (!baseElement->fastHasAttribute(itemrefAttr)) {
  78         m_itemRefElements.append(baseElement);
  79         return;
  80     }
  81
  82     DOMSettableTokenList* itemRef = baseElement->itemRef();
  83     RefPtr<DOMSettableTokenList> processedItemRef = DOMSettableTokenList::create();
  84     Node* rootNode = baseElement->treeScope()->rootNode();
  85
  86     for (Node* current = rootNode->firstChild(); current; current = current->traverseNextNode(rootNode)) {
  87         if (!current->isHTMLElement())
  88             continue;
  89         HTMLElement* element = toHTMLElement(current);
  90
  91         if (element == baseElement) {
  92             m_itemRefElements.append(element);
  93             continue;
  94         }
  95
  96         const AtomicString& id = element->getIdAttribute();
  97         if (!processedItemRef->tokens().contains(id) && itemRef->tokens().contains(id)) {
  98             processedItemRef->setValue(id);
  99             if (!element->isDescendantOf(baseElement))
 100                 m_itemRefElements.append(element);
 101         }
 102     }
 103 }
 104
 105 static Node* nextNodeWithProperty(Node* base, Node* node)
 106 {
 107     // An Microdata item may contain properties which in turn are items themselves. Properties can
 108     // also themselves be groups of name-value pairs, by putting the itemscope attribute on the element
 109     // that declares the property. If the property has an itemscope attribute specified then we need
 110     // to traverse the next sibling.
 111     return node == base || (node->isHTMLElement() && !toHTMLElement(node)->fastHasAttribute(itemscopeAttr))
 112             ? node->traverseNextNode(base) : node->traverseNextSibling(base);
 113 }
 114
 115 Element* HTMLPropertiesCollection::itemAfter(unsigned& offsetInArray, Element* previousItem) const
 116 {
 117     while (offsetInArray < m_itemRefElements.size()) {
 118         if (Element* next = itemAfter(m_itemRefElements[offsetInArray], previousItem))
 119             return next;
 120         offsetInArray++;
 121         previousItem = 0;
 122     }
 123     return 0;
 124 }
 125
 126 HTMLElement* HTMLPropertiesCollection::itemAfter(HTMLElement* base, Element* previous) const
 127 {
 128     Node* current;
 129     current = previous ? nextNodeWithProperty(base, previous) : base;
 130
 131     for (; current; current = nextNodeWithProperty(base, current)) {
 132         if (!current->isHTMLElement())
 133             continue;
 134         HTMLElement* element = toHTMLElement(current);
 135         if (element->fastHasAttribute(itempropAttr) && element->itemProp()->length()) {
 136             return element;
 137         }
 138     }
 139
 140     return 0;
 141 }
 142
 143 void HTMLPropertiesCollection::updateNameCache() const
 144 {
 145     if (m_hasPropertyNameCache)
 146         return;
 147
 148     updateRefElements();
 149
 150     for (unsigned i = 0; i < m_itemRefElements.size(); ++i) {
 151         HTMLElement* refElement = m_itemRefElements[i];
 152         for (HTMLElement* element = itemAfter(refElement, 0); element; element = itemAfter(refElement, element)) {
 153             DOMSettableTokenList* itemProperty = element->itemProp();
 154             for (unsigned propertyIndex = 0; propertyIndex < itemProperty->length(); ++propertyIndex)
 155                 updatePropertyCache(element, itemProperty->item(propertyIndex));
 156         }
 157     }
 158
 159     m_hasPropertyNameCache = true;
 160 }
 161
 162 PassRefPtr<DOMStringList> HTMLPropertiesCollection::names() const
 163 {
 164     updateNameCache();
 165     if (!m_propertyNames)
 166         m_propertyNames = DOMStringList::create();
 167     return m_propertyNames;
 168 }
 169
 170 PassRefPtr<NodeList> HTMLPropertiesCollection::namedItem(const String& name) const
 171 {
 172     updateNameCache();
 173
 174     Vector<RefPtr<Node> > namedItems;
 175     Vector<Element*>* propertyResults = m_propertyCache.get(AtomicString(name).impl());
 176     for (unsigned i = 0; propertyResults && i < propertyResults->size(); ++i)
 177         namedItems.append(propertyResults->at(i));
 178
 179     // FIXME: HTML5 specifies that this should return PropertyNodeList.
 180     return namedItems.isEmpty() ? 0 : StaticNodeList::adopt(namedItems);
 181 }
 182
 183 bool HTMLPropertiesCollection::hasNamedItem(const AtomicString& name) const
 184 {
 185     updateNameCache();
 186
 187     if (Vector<Element*>* propertyCache = m_propertyCache.get(name.impl())) {
 188         if (!propertyCache->isEmpty())
 189             return true;
 190     }
 191
 192     return false;
 193 }
 194
 195 } // namespace WebCore
 196
 197 #endif // ENABLE(MICRODATA)