[GTK] WebKitWebResource::load-failed uses the wrong marshaller
[WebKit-https.git] / Source / WebKit / gtk / webkit / webkitwebresource.cpp
1 /*
2  * Copyright (C) 2009 Jan Michael C. Alonzo
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 "webkitwebresource.h"
22
23 #include "ArchiveResource.h"
24 #include "KURL.h"
25 #include "PlatformString.h"
26 #include "SharedBuffer.h"
27 #include "webkitenumtypes.h"
28 #include "webkitglobalsprivate.h"
29 #include "webkitmarshal.h"
30 #include "webkitnetworkresponse.h"
31 #include "webkitwebresourceprivate.h"
32 #include <glib.h>
33 #include <glib/gi18n-lib.h>
34 #include <wtf/Assertions.h>
35 #include <wtf/text/CString.h>
36
37 /**
38  * SECTION:webkitwebresource
39  * @short_description: Represents a downloaded URI.
40  * @see_also: #WebKitWebDataSource
41  *
42  * A web resource encapsulates the data of the download as well as the URI,
43  * MIME type and frame name of the resource.
44  */
45
46 using namespace WebCore;
47
48 enum {
49     // Resource loading
50     RESPONSE_RECEIVED,
51     LOAD_FINISHED,
52     CONTENT_LENGTH_RECEIVED,
53     LOAD_FAILED,
54
55     LAST_SIGNAL
56 };
57
58 enum {
59     PROP_0,
60     PROP_URI,
61     PROP_MIME_TYPE,
62     PROP_ENCODING,
63     PROP_FRAME_NAME
64 };
65
66 static guint webkit_web_resource_signals[LAST_SIGNAL] = { 0, };
67
68 G_DEFINE_TYPE(WebKitWebResource, webkit_web_resource, G_TYPE_OBJECT);
69
70 static void webkit_web_resource_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec);
71 static void webkit_web_resource_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec);
72
73 static void webkit_web_resource_cleanup(WebKitWebResource* webResource)
74 {
75     WebKitWebResourcePrivate* priv = webResource->priv;
76
77     g_free(priv->uri);
78     priv->uri = NULL;
79
80     g_free(priv->mimeType);
81     priv->mimeType = NULL;
82
83     g_free(priv->textEncoding);
84     priv->textEncoding = NULL;
85
86     g_free(priv->frameName);
87     priv->frameName = NULL;
88
89     if (priv->data)
90         g_string_free(priv->data, TRUE);
91     priv->data = NULL;
92 }
93
94 static void webkit_web_resource_dispose(GObject* object)
95 {
96     WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(object);
97     WebKitWebResourcePrivate* priv = webResource->priv;
98
99     if (priv->resource) {
100         priv->resource->deref();
101         priv->resource = 0;
102     }
103
104     G_OBJECT_CLASS(webkit_web_resource_parent_class)->dispose(object);
105 }
106
107 static void webkit_web_resource_finalize(GObject* object)
108 {
109     WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(object);
110
111     webkit_web_resource_cleanup(webResource);
112
113     G_OBJECT_CLASS(webkit_web_resource_parent_class)->finalize(object);
114 }
115
116 static void webkit_web_resource_class_init(WebKitWebResourceClass* webResourceClass)
117 {
118     GObjectClass* gobject_class = G_OBJECT_CLASS(webResourceClass);
119
120     gobject_class->dispose = webkit_web_resource_dispose;
121     gobject_class->finalize = webkit_web_resource_finalize;
122     gobject_class->get_property = webkit_web_resource_get_property;
123     gobject_class->set_property = webkit_web_resource_set_property;
124
125     /**
126      * WebKitWebResource::response-received:
127      * @web_resource: the #WebKitWebResource being loaded
128      * @response: the #WebKitNetworkResponse that was received
129      *
130      * Emitted when the response is received from the server.
131      *
132      * Since: 1.7.5
133      */
134     webkit_web_resource_signals[RESPONSE_RECEIVED] = g_signal_new("response-received",
135             G_TYPE_FROM_CLASS(webResourceClass),
136             G_SIGNAL_RUN_LAST,
137             0,
138             0, 0,
139             g_cclosure_marshal_VOID__OBJECT,
140             G_TYPE_NONE, 1,
141             WEBKIT_TYPE_NETWORK_RESPONSE);
142
143     /**
144      * WebKitWebResource::load-failed:
145      * @web_resource: the #WebKitWebResource that was loaded
146      * @error: the #GError that was triggered
147      *
148      * Invoked when the @web_resource failed to load
149      *
150      * Since: 1.7.5
151      */
152     webkit_web_resource_signals[LOAD_FAILED] = g_signal_new("load-failed",
153             G_TYPE_FROM_CLASS(webResourceClass),
154             G_SIGNAL_RUN_LAST,
155             0,
156             0, 0,
157             g_cclosure_marshal_VOID__POINTER,
158             G_TYPE_NONE, 1,
159             G_TYPE_POINTER);
160
161     /**
162      * WebKitWebResource::load-finished:
163      * @web_resource: the #WebKitWebResource being loaded
164      *
165      * Emitted when all the data for the resource was loaded
166      *
167      * Since: 1.7.5
168      */
169     webkit_web_resource_signals[LOAD_FINISHED] = g_signal_new("load-finished",
170             G_TYPE_FROM_CLASS(webResourceClass),
171             G_SIGNAL_RUN_LAST,
172             0,
173             0, 0,
174             g_cclosure_marshal_VOID__VOID,
175             G_TYPE_NONE, 0);
176
177     /**
178      * WebKitWebResource::content-length-received:
179      * @web_resource: the #WebKitWebResource that was loaded
180      * @length_received: the amount of data received since the last signal emission
181      *
182      * Emitted when new resource data has been received. The
183      * @length_received variable stores the amount of bytes received
184      * since the last time this signal was emitted. This is useful to
185      * provide progress information about the resource load operation.
186      *
187      * Since: 1.7.5
188      */
189     webkit_web_resource_signals[CONTENT_LENGTH_RECEIVED] = g_signal_new("content-length-received",
190             G_TYPE_FROM_CLASS(webResourceClass),
191             G_SIGNAL_RUN_LAST,
192             0,
193             0, 0,
194             g_cclosure_marshal_VOID__INT,
195             G_TYPE_NONE, 1,
196             G_TYPE_INT);
197
198     /**
199      * WebKitWebResource:uri:
200      *
201      * The URI of the web resource
202      *
203      * Since: 1.1.14
204      */
205     g_object_class_install_property(gobject_class,
206                                     PROP_URI,
207                                     g_param_spec_string(
208                                     "uri",
209                                     _("URI"),
210                                     _("The uri of the resource"),
211                                     NULL,
212                                     (GParamFlags)(WEBKIT_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY)));
213     /**
214      * WebKitWebResource:mime-type:
215      *
216      * The MIME type of the web resource.
217      *
218      * Since: 1.1.14
219      */
220     g_object_class_install_property(gobject_class,
221                                     PROP_MIME_TYPE,
222                                     g_param_spec_string(
223                                     "mime-type",
224                                     _("MIME Type"),
225                                     _("The MIME type of the resource"),
226                                     NULL,
227                                     WEBKIT_PARAM_READABLE));
228     /**
229      * WebKitWebResource:encoding:
230      *
231      * The encoding name to which the web resource was encoded in.
232      *
233      * Since: 1.1.14
234      */
235     g_object_class_install_property(gobject_class,
236                                     PROP_ENCODING,
237                                     g_param_spec_string(
238                                     "encoding",
239                                     _("Encoding"),
240                                     _("The text encoding name of the resource"),
241                                     NULL,
242                                     WEBKIT_PARAM_READABLE));
243
244     /**
245      * WebKitWebResource:frame-name:
246      *
247      * The frame name for the web resource.
248      *
249      * Since: 1.1.14
250      */
251     g_object_class_install_property(gobject_class,
252                                     PROP_FRAME_NAME,
253                                     g_param_spec_string(
254                                     "frame-name",
255                                     _("Frame Name"),
256                                     _("The frame name of the resource"),
257                                     NULL,
258                                     WEBKIT_PARAM_READABLE));
259
260     g_type_class_add_private(gobject_class, sizeof(WebKitWebResourcePrivate));
261 }
262
263 static void webkit_web_resource_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec)
264 {
265     WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(object);
266
267     switch (prop_id) {
268     case PROP_URI:
269         g_value_set_string(value, webkit_web_resource_get_uri(webResource));
270         break;
271     case PROP_MIME_TYPE:
272         g_value_set_string(value, webkit_web_resource_get_mime_type(webResource));
273         break;
274     case PROP_ENCODING:
275         g_value_set_string(value, webkit_web_resource_get_encoding(webResource));
276         break;
277     case PROP_FRAME_NAME:
278         g_value_set_string(value, webkit_web_resource_get_frame_name(webResource));
279         break;
280     default:
281         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
282         break;
283     }
284 }
285
286 static void webkit_web_resource_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec)
287 {
288     WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(object);
289
290     switch (prop_id) {
291     case PROP_URI:
292         g_free(webResource->priv->uri);
293         webResource->priv->uri = g_value_dup_string(value);
294         break;
295     default:
296         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
297         break;
298     }
299 }
300
301 static void webkit_web_resource_init(WebKitWebResource* webResource)
302 {
303     webResource->priv = G_TYPE_INSTANCE_GET_PRIVATE(webResource, WEBKIT_TYPE_WEB_RESOURCE, WebKitWebResourcePrivate);
304 }
305
306 // internal use only
307 WebKitWebResource* webkit_web_resource_new_with_core_resource(PassRefPtr<ArchiveResource> resource)
308 {
309     WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(g_object_new(WEBKIT_TYPE_WEB_RESOURCE, NULL));
310     WebKitWebResourcePrivate* priv = webResource->priv;
311     priv->resource = resource.leakRef();
312
313     return webResource;
314 }
315
316 void webkit_web_resource_init_with_core_resource(WebKitWebResource* webResource, PassRefPtr<ArchiveResource> resource)
317 {
318     ASSERT(resource);
319
320     WebKitWebResourcePrivate* priv = webResource->priv;
321
322     if (priv->resource)
323         priv->resource->deref();
324
325     priv->resource = resource.leakRef();
326 }
327
328 /**
329  * webkit_web_resource_new:
330  * @data: the data to initialize the #WebKitWebResource
331  * @size: the length of @data
332  * @uri: the uri of the #WebKitWebResource
333  * @mime_type: the MIME type of the #WebKitWebResource
334  * @encoding: the text encoding name of the #WebKitWebResource
335  * @frame_name: the frame name of the #WebKitWebResource
336  *
337  * Returns a new #WebKitWebResource. The @encoding can be %NULL. The
338  * @frame_name argument can be used if the resource represents contents of an
339  * entire HTML frame, otherwise pass %NULL.
340  *
341  * Return value: a new #WebKitWebResource
342  *
343  * Since: 1.1.14
344  */
345 WebKitWebResource* webkit_web_resource_new(const gchar* data,
346                                            gssize size,
347                                            const gchar* uri,
348                                            const gchar* mimeType,
349                                            const gchar* encoding,
350                                            const gchar* frameName)
351 {
352     g_return_val_if_fail(data, NULL);
353     g_return_val_if_fail(uri, NULL);
354     g_return_val_if_fail(mimeType, NULL);
355
356     if (size < 0)
357         size = strlen(data);
358
359     RefPtr<SharedBuffer> buffer = SharedBuffer::create(data, size);
360     WebKitWebResource* webResource = webkit_web_resource_new_with_core_resource(ArchiveResource::create(buffer, KURL(KURL(), String::fromUTF8(uri)), String::fromUTF8(mimeType), String::fromUTF8(encoding), String::fromUTF8(frameName)));
361
362     return webResource;
363 }
364
365 /**
366  * webkit_web_resource_get_data:
367  * @web_resource: a #WebKitWebResource
368  *
369  * Returns the data of the @webResource.
370  *
371  * Return value: (transfer none): a #GString containing the character
372  * data of the @webResource.  The string is owned by WebKit and should
373  * not be freed or destroyed.
374  *
375  * Since: 1.1.14
376  */
377 GString* webkit_web_resource_get_data(WebKitWebResource* webResource)
378 {
379     g_return_val_if_fail(WEBKIT_IS_WEB_RESOURCE(webResource), NULL);
380
381     WebKitWebResourcePrivate* priv = webResource->priv;
382
383     if (!priv->resource)
384         return NULL;
385
386     if (!priv->data)
387         priv->data = g_string_new_len(priv->resource->data()->data(), priv->resource->data()->size());
388
389     return priv->data;
390 }
391
392 /**
393  * webkit_web_resource_get_uri:
394  * @web_resource: a #WebKitWebResource
395  *
396  * Return value: the URI of the resource
397  *
398  * Since: 1.1.14
399  */
400 const gchar* webkit_web_resource_get_uri(WebKitWebResource* webResource)
401 {
402     g_return_val_if_fail(WEBKIT_IS_WEB_RESOURCE(webResource), NULL);
403
404     WebKitWebResourcePrivate* priv = webResource->priv;
405
406
407     // We may have an URI without having a resource assigned to us (e.g., if the
408     // FrameLoaderClient only had a ResourceRequest when we got created
409     if (priv->uri)
410         return priv->uri;
411
412     if (!priv->resource)
413         return NULL;
414
415     priv->uri = g_strdup(priv->resource->url().string().utf8().data());
416
417     return priv->uri;
418 }
419
420 /**
421  * webkit_web_resource_get_mime_type:
422  * @web_resource: a #WebKitWebResource
423  *
424  * Return value: the MIME type of the resource
425  *
426  * Since: 1.1.14
427  */
428 const gchar* webkit_web_resource_get_mime_type(WebKitWebResource* webResource)
429 {
430     g_return_val_if_fail(WEBKIT_IS_WEB_RESOURCE(webResource), NULL);
431
432     WebKitWebResourcePrivate* priv = webResource->priv;
433     if (!priv->resource)
434         return NULL;
435
436     if (!priv->mimeType)
437         priv->mimeType = g_strdup(priv->resource->mimeType().utf8().data());
438
439     return priv->mimeType;
440 }
441
442 /**
443  * webkit_web_resource_get_encoding:
444  * @web_resource: a #WebKitWebResource
445  *
446  * Return value: the encoding name of the resource
447  *
448  * Since: 1.1.14
449  */
450 const gchar* webkit_web_resource_get_encoding(WebKitWebResource* webResource)
451 {
452     g_return_val_if_fail(WEBKIT_IS_WEB_RESOURCE(webResource), NULL);
453
454     WebKitWebResourcePrivate* priv = webResource->priv;
455     if (!priv->resource)
456         return NULL;
457
458     if (!priv->textEncoding)
459         priv->textEncoding = g_strdup(priv->resource->textEncoding().utf8().data());
460
461     return priv->textEncoding;
462 }
463
464 /**
465  * webkit_web_resource_get_frame_name:
466  * @web_resource: a #WebKitWebResource
467  *
468  * Return value: the frame name of the resource.
469  *
470  * Since: 1.1.14
471  */
472 const gchar* webkit_web_resource_get_frame_name(WebKitWebResource* webResource)
473 {
474     g_return_val_if_fail(WEBKIT_IS_WEB_RESOURCE(webResource), NULL);
475
476     WebKitWebResourcePrivate* priv = webResource->priv;
477     if (!priv->resource)
478         return NULL;
479
480     if (!priv->frameName)
481         priv->frameName = g_strdup(priv->resource->frameName().utf8().data());
482
483     return priv->frameName;
484 }
485