Replace WTF::move with WTFMove
[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 "ExceptionCode.h"
31 #include <wtf/ASCIICType.h>
32 #include <wtf/text/AtomicString.h>
33 #include <wtf/text/StringBuilder.h>
34 #include <wtf/text/WTFString.h>
35
36 namespace WebCore {
37
38 static bool isValidAttributeName(const String& name)
39 {
40     if (!name.startsWith("data-"))
41         return false;
42
43     unsigned length = name.length();
44     for (unsigned i = 5; i < length; ++i) {
45         if (isASCIIUpper(name[i]))
46             return false;
47     }
48
49     return true;
50 }
51
52 static String convertAttributeNameToPropertyName(const String& name)
53 {
54     StringBuilder stringBuilder;
55
56     unsigned length = name.length();
57     for (unsigned i = 5; i < length; ++i) {
58         UChar character = name[i];
59         if (character != '-')
60             stringBuilder.append(character);
61         else {
62             if ((i + 1 < length) && isASCIILower(name[i + 1])) {
63                 stringBuilder.append(toASCIIUpper(name[i + 1]));
64                 ++i;
65             } else
66                 stringBuilder.append(character);
67         }
68     }
69
70     return stringBuilder.toString();
71 }
72
73 static bool propertyNameMatchesAttributeName(const String& propertyName, const String& attributeName)
74 {
75     if (!attributeName.startsWith("data-"))
76         return false;
77
78     unsigned propertyLength = propertyName.length();
79     unsigned attributeLength = attributeName.length();
80
81     unsigned a = 5;
82     unsigned p = 0;
83     bool wordBoundary = false;
84     while (a < attributeLength && p < propertyLength) {
85         const UChar currentAttributeNameChar = attributeName[a];
86         if (currentAttributeNameChar == '-' && a + 1 < attributeLength && attributeName[a + 1] != '-')
87             wordBoundary = true;
88         else {
89             if ((wordBoundary ? toASCIIUpper(currentAttributeNameChar) : currentAttributeNameChar) != propertyName[p])
90                 return false;
91             p++;
92             wordBoundary = false;
93         }
94         a++;
95     }
96
97     return (a == attributeLength && p == propertyLength);
98 }
99
100 static bool isValidPropertyName(const String& name)
101 {
102     unsigned length = name.length();
103     for (unsigned i = 0; i < length; ++i) {
104         if (name[i] == '-' && (i + 1 < length) && isASCIILower(name[i + 1]))
105             return false;
106     }
107     return true;
108 }
109
110 template<typename CharacterType>
111 static inline AtomicString convertPropertyNameToAttributeName(const StringImpl& name)
112 {
113     const CharacterType dataPrefix[] = { 'd', 'a', 't', 'a', '-' };
114
115     Vector<CharacterType, 32> buffer;
116
117     unsigned length = name.length();
118     buffer.reserveInitialCapacity(WTF_ARRAY_LENGTH(dataPrefix) + length);
119
120     buffer.append(dataPrefix, WTF_ARRAY_LENGTH(dataPrefix));
121
122     const CharacterType* characters = name.characters<CharacterType>();
123     for (unsigned i = 0; i < length; ++i) {
124         CharacterType character = characters[i];
125         if (isASCIIUpper(character)) {
126             buffer.append('-');
127             buffer.append(toASCIILower(character));
128         } else
129             buffer.append(character);
130     }
131     return AtomicString(buffer.data(), buffer.size());
132 }
133
134 static AtomicString convertPropertyNameToAttributeName(const String& name)
135 {
136     if (name.isNull())
137         return nullAtom;
138
139     StringImpl* nameImpl = name.impl();
140     if (nameImpl->is8Bit())
141         return convertPropertyNameToAttributeName<LChar>(*nameImpl);
142     return convertPropertyNameToAttributeName<UChar>(*nameImpl);
143 }
144
145 void DatasetDOMStringMap::ref()
146 {
147     m_element.ref();
148 }
149
150 void DatasetDOMStringMap::deref()
151 {
152     m_element.deref();
153 }
154
155 void DatasetDOMStringMap::getNames(Vector<String>& names)
156 {
157     if (!m_element.hasAttributes())
158         return;
159
160     for (const Attribute& attribute : m_element.attributesIterator()) {
161         if (isValidAttributeName(attribute.localName()))
162             names.append(convertAttributeNameToPropertyName(attribute.localName()));
163     }
164 }
165
166 const AtomicString& DatasetDOMStringMap::item(const String& propertyName, bool& isValid)
167 {
168     isValid = false;
169     if (m_element.hasAttributes()) {
170         AttributeIteratorAccessor attributeIteratorAccessor = m_element.attributesIterator();
171
172         if (attributeIteratorAccessor.attributeCount() == 1) {
173             // If the node has a single attribute, it is the dataset member accessed in most cases.
174             // Building a new AtomicString in that case is overkill so we do a direct character comparison.
175             const Attribute& attribute = *attributeIteratorAccessor.begin();
176             if (propertyNameMatchesAttributeName(propertyName, attribute.localName())) {
177                 isValid = true;
178                 return attribute.value();
179             }
180         } else {
181             AtomicString attributeName = convertPropertyNameToAttributeName(propertyName);
182             for (const Attribute& attribute : attributeIteratorAccessor) {
183                 if (attribute.localName() == attributeName) {
184                     isValid = true;
185                     return attribute.value();
186                 }
187             }
188         }
189     }
190
191     return nullAtom;
192 }
193
194 void DatasetDOMStringMap::setItem(const String& name, const String& value, ExceptionCode& ec)
195 {
196     if (!isValidPropertyName(name)) {
197         ec = SYNTAX_ERR;
198         return;
199     }
200
201     m_element.setAttribute(convertPropertyNameToAttributeName(name), value, ec);
202 }
203
204 bool DatasetDOMStringMap::deleteItem(const String& name)
205 {
206     return m_element.removeAttribute(convertPropertyNameToAttributeName(name));
207 }
208
209 } // namespace WebCore