0b1b4ba4b399994f3f2e8dd7cb6a31dd0eee153e
[WebKit-https.git] / Source / WebKit / WebProcess / InjectedBundle / API / gtk / DOM / WebKitDOMDOMTokenList.cpp
1 /*
2  *  This file is part of the WebKit open source project.
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Library General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Library General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Library General Public License
15  *  along with this library; see the file COPYING.LIB.  If not, write to
16  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  *  Boston, MA 02110-1301, USA.
18  */
19
20 #include "config.h"
21 #include "WebKitDOMDOMTokenList.h"
22
23 #include <WebCore/CSSImportRule.h>
24 #include "DOMObjectCache.h"
25 #include <WebCore/Document.h>
26 #include <WebCore/ExceptionCode.h>
27 #include <WebCore/ExceptionCodeDescription.h>
28 #include <WebCore/JSMainThreadExecState.h>
29 #include "WebKitDOMDOMTokenListPrivate.h"
30 #include "WebKitDOMPrivate.h"
31 #include "ConvertToUTF8String.h"
32 #include <wtf/GetPtr.h>
33 #include <wtf/RefPtr.h>
34
35 #define WEBKIT_DOM_DOM_TOKEN_LIST_GET_PRIVATE(obj) G_TYPE_INSTANCE_GET_PRIVATE(obj, WEBKIT_DOM_TYPE_DOM_TOKEN_LIST, WebKitDOMDOMTokenListPrivate)
36
37 typedef struct _WebKitDOMDOMTokenListPrivate {
38     RefPtr<WebCore::DOMTokenList> coreObject;
39 } WebKitDOMDOMTokenListPrivate;
40
41 namespace WebKit {
42
43 WebKitDOMDOMTokenList* kit(WebCore::DOMTokenList* obj)
44 {
45     if (!obj)
46         return 0;
47
48     if (gpointer ret = DOMObjectCache::get(obj))
49         return WEBKIT_DOM_DOM_TOKEN_LIST(ret);
50
51     return wrapDOMTokenList(obj);
52 }
53
54 WebCore::DOMTokenList* core(WebKitDOMDOMTokenList* request)
55 {
56     return request ? static_cast<WebCore::DOMTokenList*>(WEBKIT_DOM_OBJECT(request)->coreObject) : 0;
57 }
58
59 WebKitDOMDOMTokenList* wrapDOMTokenList(WebCore::DOMTokenList* coreObject)
60 {
61     ASSERT(coreObject);
62     return WEBKIT_DOM_DOM_TOKEN_LIST(g_object_new(WEBKIT_DOM_TYPE_DOM_TOKEN_LIST, "core-object", coreObject, nullptr));
63 }
64
65 } // namespace WebKit
66
67 G_DEFINE_TYPE(WebKitDOMDOMTokenList, webkit_dom_dom_token_list, WEBKIT_DOM_TYPE_OBJECT)
68
69 enum {
70     PROP_0,
71     PROP_LENGTH,
72     PROP_VALUE,
73 };
74
75 static void webkit_dom_dom_token_list_finalize(GObject* object)
76 {
77     WebKitDOMDOMTokenListPrivate* priv = WEBKIT_DOM_DOM_TOKEN_LIST_GET_PRIVATE(object);
78
79     WebKit::DOMObjectCache::forget(priv->coreObject.get());
80
81     priv->~WebKitDOMDOMTokenListPrivate();
82     G_OBJECT_CLASS(webkit_dom_dom_token_list_parent_class)->finalize(object);
83 }
84
85 static void webkit_dom_dom_token_list_set_property(GObject* object, guint propertyId, const GValue* value, GParamSpec* pspec)
86 {
87     WebKitDOMDOMTokenList* self = WEBKIT_DOM_DOM_TOKEN_LIST(object);
88
89     switch (propertyId) {
90     case PROP_VALUE:
91         webkit_dom_dom_token_list_set_value(self, g_value_get_string(value));
92         break;
93     default:
94         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, pspec);
95         break;
96     }
97 }
98
99 static void webkit_dom_dom_token_list_get_property(GObject* object, guint propertyId, GValue* value, GParamSpec* pspec)
100 {
101     WebKitDOMDOMTokenList* self = WEBKIT_DOM_DOM_TOKEN_LIST(object);
102
103     switch (propertyId) {
104     case PROP_LENGTH:
105         g_value_set_ulong(value, webkit_dom_dom_token_list_get_length(self));
106         break;
107     case PROP_VALUE:
108         g_value_take_string(value, webkit_dom_dom_token_list_get_value(self));
109         break;
110     default:
111         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propertyId, pspec);
112         break;
113     }
114 }
115
116 static GObject* webkit_dom_dom_token_list_constructor(GType type, guint constructPropertiesCount, GObjectConstructParam* constructProperties)
117 {
118     GObject* object = G_OBJECT_CLASS(webkit_dom_dom_token_list_parent_class)->constructor(type, constructPropertiesCount, constructProperties);
119
120     WebKitDOMDOMTokenListPrivate* priv = WEBKIT_DOM_DOM_TOKEN_LIST_GET_PRIVATE(object);
121     priv->coreObject = static_cast<WebCore::DOMTokenList*>(WEBKIT_DOM_OBJECT(object)->coreObject);
122     WebKit::DOMObjectCache::put(priv->coreObject.get(), object);
123
124     return object;
125 }
126
127 static void webkit_dom_dom_token_list_class_init(WebKitDOMDOMTokenListClass* requestClass)
128 {
129     GObjectClass* gobjectClass = G_OBJECT_CLASS(requestClass);
130     g_type_class_add_private(gobjectClass, sizeof(WebKitDOMDOMTokenListPrivate));
131     gobjectClass->constructor = webkit_dom_dom_token_list_constructor;
132     gobjectClass->finalize = webkit_dom_dom_token_list_finalize;
133     gobjectClass->set_property = webkit_dom_dom_token_list_set_property;
134     gobjectClass->get_property = webkit_dom_dom_token_list_get_property;
135
136     g_object_class_install_property(
137         gobjectClass,
138         PROP_LENGTH,
139         g_param_spec_ulong(
140             "length",
141             "DOMTokenList:length",
142             "read-only gulong DOMTokenList:length",
143             0, G_MAXULONG, 0,
144             WEBKIT_PARAM_READABLE));
145
146     g_object_class_install_property(
147         gobjectClass,
148         PROP_VALUE,
149         g_param_spec_string(
150             "value",
151             "DOMTokenList:value",
152             "read-write gchar* DOMTokenList:value",
153             "",
154             WEBKIT_PARAM_READWRITE));
155
156 }
157
158 static void webkit_dom_dom_token_list_init(WebKitDOMDOMTokenList* request)
159 {
160     WebKitDOMDOMTokenListPrivate* priv = WEBKIT_DOM_DOM_TOKEN_LIST_GET_PRIVATE(request);
161     new (priv) WebKitDOMDOMTokenListPrivate();
162 }
163
164 gchar* webkit_dom_dom_token_list_item(WebKitDOMDOMTokenList* self, gulong index)
165 {
166     WebCore::JSMainThreadNullState state;
167     g_return_val_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self), 0);
168     WebCore::DOMTokenList* item = WebKit::core(self);
169     gchar* result = convertToUTF8String(item->item(index));
170     return result;
171 }
172
173 gboolean webkit_dom_dom_token_list_contains(WebKitDOMDOMTokenList* self, const gchar* token)
174 {
175     WebCore::JSMainThreadNullState state;
176     g_return_val_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self), FALSE);
177     g_return_val_if_fail(token, FALSE);
178     WebCore::DOMTokenList* item = WebKit::core(self);
179     WTF::String convertedToken = WTF::String::fromUTF8(token);
180     gboolean result = item->contains(convertedToken);
181     return result;
182 }
183
184 void webkit_dom_dom_token_list_add(WebKitDOMDOMTokenList* self, GError** error, ...)
185 {
186     WebCore::JSMainThreadNullState state;
187     g_return_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self));
188     g_return_if_fail(!error || !*error);
189     WebCore::DOMTokenList* item = WebKit::core(self);
190     va_list variadicParameterList;
191     Vector<WTF::String> convertedTokens;
192     va_start(variadicParameterList, error);
193     while (gchar* variadicParameter = va_arg(variadicParameterList, gchar*))
194         convertedTokens.append(WTF::String::fromUTF8(variadicParameter));
195     va_end(variadicParameterList);
196     auto result = item->add(WTFMove(convertedTokens));
197     if (result.hasException()) {
198         WebCore::ExceptionCodeDescription ecdesc(result.releaseException().code());
199         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
200     }
201 }
202
203 void webkit_dom_dom_token_list_remove(WebKitDOMDOMTokenList* self, GError** error, ...)
204 {
205     WebCore::JSMainThreadNullState state;
206     g_return_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self));
207     g_return_if_fail(!error || !*error);
208     WebCore::DOMTokenList* item = WebKit::core(self);
209     va_list variadicParameterList;
210     Vector<WTF::String> convertedTokens;
211     va_start(variadicParameterList, error);
212     while (gchar* variadicParameter = va_arg(variadicParameterList, gchar*))
213         convertedTokens.append(WTF::String::fromUTF8(variadicParameter));
214     va_end(variadicParameterList);
215     auto result = item->remove(WTFMove(convertedTokens));
216     if (result.hasException()) {
217         WebCore::ExceptionCodeDescription ecdesc(result.releaseException().code());
218         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
219     }
220 }
221
222 gboolean webkit_dom_dom_token_list_toggle(WebKitDOMDOMTokenList* self, const gchar* token, gboolean force, GError** error)
223 {
224     WebCore::JSMainThreadNullState state;
225     g_return_val_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self), FALSE);
226     g_return_val_if_fail(token, FALSE);
227     g_return_val_if_fail(!error || !*error, FALSE);
228     WebCore::DOMTokenList* item = WebKit::core(self);
229     WTF::String convertedToken = WTF::String::fromUTF8(token);
230     auto result = item->toggle(convertedToken, force);
231     if (result.hasException()) {
232         WebCore::ExceptionCodeDescription ecdesc(result.releaseException().code());
233         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
234         return false;
235     }
236     return result.releaseReturnValue();
237 }
238
239 void webkit_dom_dom_token_list_replace(WebKitDOMDOMTokenList* self, const gchar* token, const gchar* newToken, GError** error)
240 {
241     WebCore::JSMainThreadNullState state;
242     g_return_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self));
243     g_return_if_fail(token);
244     g_return_if_fail(newToken);
245     g_return_if_fail(!error || !*error);
246     WebCore::DOMTokenList* item = WebKit::core(self);
247     WTF::String convertedToken = WTF::String::fromUTF8(token);
248     WTF::String convertedNewToken = WTF::String::fromUTF8(newToken);
249     auto result = item->replace(convertedToken, convertedNewToken);
250     if (result.hasException()) {
251         WebCore::ExceptionCodeDescription ecdesc(result.releaseException().code());
252         g_set_error_literal(error, g_quark_from_string("WEBKIT_DOM"), ecdesc.code, ecdesc.name);
253     }
254 }
255
256 gulong webkit_dom_dom_token_list_get_length(WebKitDOMDOMTokenList* self)
257 {
258     WebCore::JSMainThreadNullState state;
259     g_return_val_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self), 0);
260     WebCore::DOMTokenList* item = WebKit::core(self);
261     gulong result = item->length();
262     return result;
263 }
264
265 gchar* webkit_dom_dom_token_list_get_value(WebKitDOMDOMTokenList* self)
266 {
267     WebCore::JSMainThreadNullState state;
268     g_return_val_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self), 0);
269     WebCore::DOMTokenList* item = WebKit::core(self);
270     gchar* result = convertToUTF8String(item->value());
271     return result;
272 }
273
274 void webkit_dom_dom_token_list_set_value(WebKitDOMDOMTokenList* self, const gchar* value)
275 {
276     WebCore::JSMainThreadNullState state;
277     g_return_if_fail(WEBKIT_DOM_IS_DOM_TOKEN_LIST(self));
278     g_return_if_fail(value);
279     WebCore::DOMTokenList* item = WebKit::core(self);
280     WTF::String convertedValue = WTF::String::fromUTF8(value);
281     item->setValue(convertedValue);
282 }
283