f2d84207b97a3364954d730a10b488e3e383c648
[WebKit-https.git] / Source / WebCore / dom / DatasetDOMStringMap.cpp
1 /*
2  * Copyright (C) 2010, 2014 Apple 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "DatasetDOMStringMap.h"
28
29 #include "Element.h"
30 #include <wtf/ASCIICType.h>
31 #include <wtf/text/AtomicString.h>
32 #include <wtf/text/StringBuilder.h>
33
34 namespace WebCore {
35
36 static bool isValidAttributeName(const String& name)
37 {
38     if (!name.startsWith("data-"))
39         return false;
40
41     unsigned length = name.length();
42     for (unsigned i = 5; i < length; ++i) {
43         if (isASCIIUpper(name[i]))
44             return false;
45     }
46
47     return true;
48 }
49
50 static String convertAttributeNameToPropertyName(const String& name)
51 {
52     StringBuilder stringBuilder;
53
54     unsigned length = name.length();
55     for (unsigned i = 5; i < length; ++i) {
56         UChar character = name[i];
57         if (character != '-')
58             stringBuilder.append(character);
59         else {
60             if ((i + 1 < length) && isASCIILower(name[i + 1])) {
61                 stringBuilder.append(toASCIIUpper(name[i + 1]));
62                 ++i;
63             } else
64                 stringBuilder.append(character);
65         }
66     }
67
68     return stringBuilder.toString();
69 }
70
71 static bool propertyNameMatchesAttributeName(const String& propertyName, const String& attributeName)
72 {
73     if (!attributeName.startsWith("data-"))
74         return false;
75
76     unsigned propertyLength = propertyName.length();
77     unsigned attributeLength = attributeName.length();
78
79     unsigned a = 5;
80     unsigned p = 0;
81     bool wordBoundary = false;
82     while (a < attributeLength && p < propertyLength) {
83         const UChar currentAttributeNameChar = attributeName[a];
84         if (currentAttributeNameChar == '-' && a + 1 < attributeLength && attributeName[a + 1] != '-')
85             wordBoundary = true;
86         else {
87             if ((wordBoundary ? toASCIIUpper(currentAttributeNameChar) : currentAttributeNameChar) != propertyName[p])
88                 return false;
89             p++;
90             wordBoundary = false;
91         }
92         a++;
93     }
94
95     return (a == attributeLength && p == propertyLength);
96 }
97
98 static bool isValidPropertyName(const String& name)
99 {
100     unsigned length = name.length();
101     for (unsigned i = 0; i < length; ++i) {
102         if (name[i] == '-' && (i + 1 < length) && isASCIILower(name[i + 1]))
103             return false;
104     }
105     return true;
106 }
107
108 template<typename CharacterType>
109 static inline AtomicString convertPropertyNameToAttributeName(const StringImpl& name)
110 {
111     const CharacterType dataPrefix[] = { 'd', 'a', 't', 'a', '-' };
112
113     Vector<CharacterType, 32> buffer;
114
115     unsigned length = name.length();
116     buffer.reserveInitialCapacity(WTF_ARRAY_LENGTH(dataPrefix) + length);
117
118     buffer.append(dataPrefix, WTF_ARRAY_LENGTH(dataPrefix));
119
120     const CharacterType* characters = name.characters<CharacterType>();
121     for (unsigned i = 0; i < length; ++i) {
122         CharacterType character = characters[i];
123         if (isASCIIUpper(character)) {
124             buffer.append('-');
125             buffer.append(toASCIILower(character));
126         } else
127             buffer.append(character);
128     }
129     return AtomicString(buffer.data(), buffer.size());
130 }
131
132 static AtomicString convertPropertyNameToAttributeName(const String& name)
133 {
134     if (name.isNull())
135         return nullAtom();
136
137     StringImpl* nameImpl = name.impl();
138     if (nameImpl->is8Bit())
139         return convertPropertyNameToAttributeName<LChar>(*nameImpl);
140     return convertPropertyNameToAttributeName<UChar>(*nameImpl);
141 }
142
143 void DatasetDOMStringMap::ref()
144 {
145     m_element.ref();
146 }
147
148 void DatasetDOMStringMap::deref()
149 {
150     m_element.deref();
151 }
152
153 bool DatasetDOMStringMap::isSupportedPropertyName(const String& propertyName) const
154 {
155     if (!m_element.hasAttributes())
156         return false;
157
158     auto attributeIteratorAccessor = m_element.attributesIterator();
159     if (attributeIteratorAccessor.attributeCount() == 1) {
160         // If the node has a single attribute, it is the dataset member accessed in most cases.
161         // Building a new AtomicString in that case is overkill so we do a direct character comparison.
162         const auto& attribute = *attributeIteratorAccessor.begin();
163         if (propertyNameMatchesAttributeName(propertyName, attribute.localName()))
164             return true;
165     } else {
166         auto attributeName = convertPropertyNameToAttributeName(propertyName);
167         for (const Attribute& attribute : attributeIteratorAccessor) {
168             if (attribute.localName() == attributeName)
169                 return true;
170         }
171     }
172     
173     return false;
174 }
175
176 Vector<String> DatasetDOMStringMap::supportedPropertyNames() const
177 {
178     Vector<String> names;
179
180     if (!m_element.hasAttributes())
181         return names;
182
183     for (auto& attribute : m_element.attributesIterator()) {
184         if (isValidAttributeName(attribute.localName()))
185             names.append(convertAttributeNameToPropertyName(attribute.localName()));
186     }
187
188     return names;
189 }
190
191 std::optional<const AtomicString&> DatasetDOMStringMap::item(const String& propertyName) const
192 {
193     if (m_element.hasAttributes()) {
194         AttributeIteratorAccessor attributeIteratorAccessor = m_element.attributesIterator();
195
196         if (attributeIteratorAccessor.attributeCount() == 1) {
197             // If the node has a single attribute, it is the dataset member accessed in most cases.
198             // Building a new AtomicString in that case is overkill so we do a direct character comparison.
199             const Attribute& attribute = *attributeIteratorAccessor.begin();
200             if (propertyNameMatchesAttributeName(propertyName, attribute.localName()))
201                 return attribute.value();
202         } else {
203             AtomicString attributeName = convertPropertyNameToAttributeName(propertyName);
204             for (const Attribute& attribute : attributeIteratorAccessor) {
205                 if (attribute.localName() == attributeName)
206                     return attribute.value();
207             }
208         }
209     }
210
211     return std::nullopt;
212 }
213
214 String DatasetDOMStringMap::namedItem(const AtomicString& name) const
215 {
216     return item(name).value_or(String { });
217 }
218
219 ExceptionOr<void> DatasetDOMStringMap::setNamedItem(const String& name, const String& value)
220 {
221     if (!isValidPropertyName(name))
222         return Exception { SyntaxError };
223     return m_element.setAttribute(convertPropertyNameToAttributeName(name), value);
224 }
225
226 bool DatasetDOMStringMap::deleteNamedProperty(const String& name)
227 {
228     return m_element.removeAttribute(convertPropertyNameToAttributeName(name));
229 }
230
231 } // namespace WebCore