← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebKit2/Shared/UserMessageCoders.h

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/WebKit2/Shared/UserMessageCoders.h
 
1
/*
 
2
 * Copyright (C) 2010 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
#ifndef UserMessageCoders_h
 
27
#define UserMessageCoders_h
 
28
 
 
29
#include "ArgumentDecoder.h"
 
30
#include "ArgumentEncoder.h"
 
31
#include "DataReference.h"
 
32
#include "ImmutableArray.h"
 
33
#include "ImmutableDictionary.h"
 
34
#include "ShareableBitmap.h"
 
35
#include "WebCertificateInfo.h"
 
36
#include "WebCoreArgumentCoders.h"
 
37
#include "WebData.h"
 
38
#include "WebGeometry.h"
 
39
#include "WebImage.h"
 
40
#include "WebNumber.h"
 
41
#include "WebRenderLayer.h"
 
42
#include "WebRenderObject.h"
 
43
#include "WebSerializedScriptValue.h"
 
44
#include "WebString.h"
 
45
#include "WebURL.h"
 
46
#include "WebURLRequest.h"
 
47
#include "WebUserContentURLPattern.h"
 
48
 
 
49
namespace WebKit {
 
50
 
 
51
//   - Null -> Null
 
52
//   - Array -> Array
 
53
//   - Dictionary -> Dictionary
 
54
//   - SerializedScriptValue -> SerializedScriptValue
 
55
//   - String -> String
 
56
//   - UserContentURLPattern -> UserContentURLPattern
 
57
//   - WebCertificateInfo -> WebCertificateInfo
 
58
//   - WebData -> WebData
 
59
//   - WebDouble -> WebDouble
 
60
//   - WebImage -> WebImage
 
61
//   - WebRenderLayer -> WebRenderLayer
 
62
//   - WebRenderObject -> WebRenderObject
 
63
//   - WebUInt64 -> WebUInt64
 
64
//   - WebURL -> WebURL
 
65
//   - WebURLRequest -> WebURLRequest
 
66
 
 
67
template<typename Owner>
 
68
class UserMessageEncoder {
 
69
public:
 
70
    bool baseEncode(CoreIPC::ArgumentEncoder& encoder, APIObject::Type& type) const
 
71
    {
 
72
        if (!m_root) {
 
73
            encoder << static_cast<uint32_t>(APIObject::TypeNull);
 
74
            return true;
 
75
        }
 
76
 
 
77
        type = m_root->type();
 
78
        encoder << static_cast<uint32_t>(type);
 
79
 
 
80
        switch (type) {
 
81
        case APIObject::TypeArray: {
 
82
            ImmutableArray* array = static_cast<ImmutableArray*>(m_root);
 
83
            encoder << static_cast<uint64_t>(array->size());
 
84
            for (size_t i = 0; i < array->size(); ++i)
 
85
                encoder << Owner(array->at(i));
 
86
            return true;
 
87
        }
 
88
        case APIObject::TypeDictionary: {
 
89
            ImmutableDictionary* dictionary = static_cast<ImmutableDictionary*>(m_root);
 
90
            const ImmutableDictionary::MapType& map = dictionary->map();
 
91
            encoder << static_cast<uint64_t>(map.size());
 
92
 
 
93
            ImmutableDictionary::MapType::const_iterator it = map.begin();
 
94
            ImmutableDictionary::MapType::const_iterator end = map.end();
 
95
            for (; it != end; ++it) {
 
96
                encoder << it->key;
 
97
                encoder << Owner(it->value.get());
 
98
            }
 
99
            return true;
 
100
        }
 
101
        case APIObject::TypeString: {
 
102
            WebString* string = static_cast<WebString*>(m_root);
 
103
            encoder << string->string();
 
104
            return true;
 
105
        }
 
106
        case APIObject::TypeSerializedScriptValue: {
 
107
            WebSerializedScriptValue* scriptValue = static_cast<WebSerializedScriptValue*>(m_root);
 
108
            encoder << scriptValue->dataReference();
 
109
            return true;
 
110
        }
 
111
        case APIObject::TypeBoolean: {
 
112
            WebBoolean* booleanObject = static_cast<WebBoolean*>(m_root);
 
113
            encoder << booleanObject->value();
 
114
            return true;
 
115
        }
 
116
        case APIObject::TypeDouble: {
 
117
            WebDouble* doubleObject = static_cast<WebDouble*>(m_root);
 
118
            encoder << doubleObject->value();
 
119
            return true;
 
120
        }
 
121
        case APIObject::TypeUInt64: {
 
122
            WebUInt64* uint64Object = static_cast<WebUInt64*>(m_root);
 
123
            encoder << uint64Object->value();
 
124
            return true;
 
125
        }
 
126
        case APIObject::TypePoint: {
 
127
            WebPoint* pointObject = static_cast<WebPoint*>(m_root);
 
128
            encoder << pointObject->point().x;
 
129
            encoder << pointObject->point().y;
 
130
            return true;
 
131
        }
 
132
        case APIObject::TypeSize: {
 
133
            WebSize* sizeObject = static_cast<WebSize*>(m_root);
 
134
            encoder << sizeObject->size().width;
 
135
            encoder << sizeObject->size().height;
 
136
            return true;
 
137
        }
 
138
        case APIObject::TypeRect: {
 
139
            WebRect* rectObject = static_cast<WebRect*>(m_root);
 
140
            encoder << rectObject->rect().origin.x;
 
141
            encoder << rectObject->rect().origin.y;
 
142
            encoder << rectObject->rect().size.width;
 
143
            encoder << rectObject->rect().size.height;
 
144
            return true;
 
145
        }
 
146
        case APIObject::TypeRenderLayer: {
 
147
            WebRenderLayer* renderLayer = static_cast<WebRenderLayer*>(m_root);
 
148
            encoder << Owner(renderLayer->renderer());
 
149
            encoder << renderLayer->isReflection();
 
150
            encoder << renderLayer->isClipping();
 
151
            encoder << renderLayer->isClipped();
 
152
            encoder << static_cast<uint32_t>(renderLayer->compositingLayerType());
 
153
            encoder << renderLayer->absoluteBoundingBox();
 
154
            encoder << Owner(renderLayer->negativeZOrderList());
 
155
            encoder << Owner(renderLayer->normalFlowList());
 
156
            encoder << Owner(renderLayer->positiveZOrderList());
 
157
            return true;
 
158
        }
 
159
        case APIObject::TypeRenderObject: {
 
160
            WebRenderObject* renderObject = static_cast<WebRenderObject*>(m_root);
 
161
            encoder << renderObject->name();
 
162
            encoder << renderObject->elementTagName();
 
163
            encoder << renderObject->elementID();
 
164
            encoder << Owner(renderObject->elementClassNames());
 
165
            encoder << renderObject->absolutePosition();
 
166
            encoder << renderObject->frameRect();
 
167
            encoder << Owner(renderObject->children().get());
 
168
            return true;
 
169
        }
 
170
        case APIObject::TypeURL: {
 
171
            WebURL* urlObject = static_cast<WebURL*>(m_root);
 
172
            encoder << urlObject->string();
 
173
            return true;
 
174
        }
 
175
        case APIObject::TypeURLRequest: {
 
176
            WebURLRequest* urlRequestObject = static_cast<WebURLRequest*>(m_root);
 
177
            encoder << urlRequestObject->resourceRequest();
 
178
            return true;
 
179
        }
 
180
        case APIObject::TypeUserContentURLPattern: {
 
181
            WebUserContentURLPattern* urlPattern = static_cast<WebUserContentURLPattern*>(m_root);
 
182
            encoder << urlPattern->patternString();
 
183
            return true;
 
184
        }
 
185
        case APIObject::TypeImage: {
 
186
            WebImage* image = static_cast<WebImage*>(m_root);
 
187
 
 
188
            ShareableBitmap::Handle handle;
 
189
            ASSERT(!image->bitmap() || image->bitmap()->isBackedBySharedMemory());            
 
190
            if (!image->bitmap() || !image->bitmap()->isBackedBySharedMemory() || !image->bitmap()->createHandle(handle)) {
 
191
                // Initial false indicates no allocated bitmap or is not shareable.
 
192
                encoder << false;
 
193
                return true;
 
194
            }
 
195
 
 
196
            // Initial true indicates a bitmap was allocated and is shareable.
 
197
            encoder << true;
 
198
 
 
199
            encoder << handle;
 
200
            return true;
 
201
        }
 
202
        case APIObject::TypeData: {
 
203
            WebData* data = static_cast<WebData*>(m_root);
 
204
            encoder << data->dataReference();
 
205
            return true;
 
206
        }
 
207
        case APIObject::TypeCertificateInfo: {
 
208
            WebCertificateInfo* certificateInfo = static_cast<WebCertificateInfo*>(m_root);
 
209
            encoder << certificateInfo->platformCertificateInfo();
 
210
            return true;
 
211
        }
 
212
        default:
 
213
            break;
 
214
        }
 
215
 
 
216
        return false;
 
217
    }
 
218
 
 
219
protected:
 
220
    UserMessageEncoder(APIObject* root) 
 
221
        : m_root(root)
 
222
    {
 
223
    }
 
224
 
 
225
    APIObject* m_root;
 
226
};
 
227
 
 
228
 
 
229
// Handles
 
230
//   - Null -> Null
 
231
//   - Array -> Array
 
232
//   - Dictionary -> Dictionary
 
233
//   - SerializedScriptValue -> SerializedScriptValue
 
234
//   - String -> String
 
235
//   - UserContentURLPattern -> UserContentURLPattern
 
236
//   - WebCertificateInfo -> WebCertificateInfo
 
237
//   - WebData -> WebData
 
238
//   - WebDouble -> WebDouble
 
239
//   - WebImage -> WebImage
 
240
//   - WebUInt64 -> WebUInt64
 
241
//   - WebURL -> WebURL
 
242
//   - WebURLRequest -> WebURLRequest
 
243
 
 
244
template<typename Owner>
 
245
class UserMessageDecoder {
 
246
public:
 
247
    static bool baseDecode(CoreIPC::ArgumentDecoder* decoder, Owner& coder, APIObject::Type& type)
 
248
    {
 
249
        uint32_t typeAsUInt32;
 
250
        if (!decoder->decode(typeAsUInt32))
 
251
            return false;
 
252
 
 
253
        type = static_cast<APIObject::Type>(typeAsUInt32);
 
254
 
 
255
        switch (type) {
 
256
        case APIObject::TypeArray: {
 
257
            uint64_t size;
 
258
            if (!decoder->decode(size))
 
259
                return false;
 
260
 
 
261
            Vector<RefPtr<APIObject> > vector;
 
262
            for (size_t i = 0; i < size; ++i) {
 
263
                RefPtr<APIObject> element;
 
264
                Owner messageCoder(coder, element);
 
265
                if (!decoder->decode(messageCoder))
 
266
                    return false;
 
267
                vector.append(element.release());
 
268
            }
 
269
 
 
270
            coder.m_root = ImmutableArray::adopt(vector);
 
271
            break;
 
272
        }
 
273
        case APIObject::TypeDictionary: {
 
274
            uint64_t size;
 
275
            if (!decoder->decode(size))
 
276
                return false;
 
277
 
 
278
            ImmutableDictionary::MapType map;
 
279
            for (size_t i = 0; i < size; ++i) {
 
280
                String key;
 
281
                if (!decoder->decode(key))
 
282
                    return false;
 
283
 
 
284
                RefPtr<APIObject> element;
 
285
                Owner messageCoder(coder, element);
 
286
                if (!decoder->decode(messageCoder))
 
287
                    return false;
 
288
 
 
289
                ImmutableDictionary::MapType::AddResult result = map.set(key, element.release());
 
290
                if (!result.isNewEntry)
 
291
                    return false;
 
292
            }
 
293
 
 
294
            coder.m_root = ImmutableDictionary::adopt(map);
 
295
            break;
 
296
        }
 
297
        case APIObject::TypeString: {
 
298
            String string;
 
299
            if (!decoder->decode(string))
 
300
                return false;
 
301
            coder.m_root = WebString::create(string);
 
302
            break;
 
303
        }
 
304
        case APIObject::TypeSerializedScriptValue: {
 
305
            CoreIPC::DataReference dataReference;
 
306
            if (!decoder->decode(dataReference))
 
307
                return false;
 
308
            
 
309
            Vector<uint8_t> vector = dataReference.vector();
 
310
            coder.m_root = WebSerializedScriptValue::adopt(vector);
 
311
            break;
 
312
        }
 
313
        case APIObject::TypeDouble: {
 
314
            double value;
 
315
            if (!decoder->decode(value))
 
316
                return false;
 
317
            coder.m_root = WebDouble::create(value);
 
318
            break;
 
319
        }
 
320
        case APIObject::TypeUInt64: {
 
321
            uint64_t value;
 
322
            if (!decoder->decode(value))
 
323
                return false;
 
324
            coder.m_root = WebUInt64::create(value);
 
325
            break;
 
326
        }
 
327
        case APIObject::TypeBoolean: {
 
328
            bool value;
 
329
            if (!decoder->decode(value))
 
330
                return false;
 
331
            coder.m_root = WebBoolean::create(value);
 
332
            break;
 
333
        }
 
334
        case APIObject::TypeSize: {
 
335
            double width;
 
336
            double height;
 
337
            if (!decoder->decode(width))
 
338
                return false;
 
339
            if (!decoder->decode(height))
 
340
                return false;
 
341
            coder.m_root = WebSize::create(WKSizeMake(width, height));
 
342
            break;
 
343
        }
 
344
        case APIObject::TypePoint: {
 
345
            double x;
 
346
            double y;
 
347
            if (!decoder->decode(x))
 
348
                return false;
 
349
            if (!decoder->decode(y))
 
350
                return false;
 
351
            coder.m_root = WebPoint::create(WKPointMake(x, y));
 
352
            break;
 
353
        }
 
354
        case APIObject::TypeRect: {
 
355
            double x;
 
356
            double y;
 
357
            double width;
 
358
            double height;
 
359
            if (!decoder->decode(x))
 
360
                return false;
 
361
            if (!decoder->decode(y))
 
362
                return false;
 
363
            if (!decoder->decode(width))
 
364
                return false;
 
365
            if (!decoder->decode(height))
 
366
                return false;
 
367
            coder.m_root = WebRect::create(WKRectMake(x, y, width, height));
 
368
            break;
 
369
        }
 
370
        case APIObject::TypeRenderLayer: {
 
371
            RefPtr<APIObject> renderer;
 
372
            bool isReflection;
 
373
            bool isClipping;
 
374
            bool isClipped;
 
375
            uint32_t compositingLayerTypeAsUInt32;
 
376
            WebCore::IntRect absoluteBoundingBox;
 
377
            RefPtr<APIObject> negativeZOrderList;
 
378
            RefPtr<APIObject> normalFlowList;
 
379
            RefPtr<APIObject> positiveZOrderList;
 
380
 
 
381
            Owner rendererCoder(coder, renderer);
 
382
            if (!decoder->decode(rendererCoder))
 
383
                return false;
 
384
            if (renderer->type() != APIObject::TypeRenderObject)
 
385
                return false;
 
386
            if (!decoder->decodeBool(isReflection))
 
387
                return false;
 
388
            if (!decoder->decodeBool(isClipping))
 
389
                return false;
 
390
            if (!decoder->decodeBool(isClipped))
 
391
                return false;
 
392
            if (!decoder->decodeUInt32(compositingLayerTypeAsUInt32))
 
393
                return false;
 
394
            if (!decoder->decode(absoluteBoundingBox))
 
395
                return false;
 
396
            Owner negativeZOrderListCoder(coder, negativeZOrderList);
 
397
            if (!decoder->decode(negativeZOrderListCoder))
 
398
                return false;
 
399
            Owner normalFlowListCoder(coder, normalFlowList);
 
400
            if (!decoder->decode(normalFlowListCoder))
 
401
                return false;
 
402
            Owner positiveZOrderListCoder(coder, positiveZOrderList);
 
403
            if (!decoder->decode(positiveZOrderListCoder))
 
404
                return false;
 
405
            coder.m_root = WebRenderLayer::create(static_pointer_cast<WebRenderObject>(renderer), isReflection, isClipping, isClipped, static_cast<WebRenderLayer::CompositingLayerType>(compositingLayerTypeAsUInt32),
 
406
                absoluteBoundingBox, static_pointer_cast<MutableArray>(negativeZOrderList), static_pointer_cast<MutableArray>(normalFlowList),
 
407
                static_pointer_cast<MutableArray>(positiveZOrderList));
 
408
            break;
 
409
        }
 
410
        case APIObject::TypeRenderObject: {
 
411
            String name;
 
412
            String elementTagName;
 
413
            String elementID;
 
414
            RefPtr<APIObject> elementClassNames;
 
415
            WebCore::IntPoint absolutePosition;
 
416
            WebCore::IntRect frameRect;
 
417
            RefPtr<APIObject> children;
 
418
            
 
419
            if (!decoder->decode(name))
 
420
                return false;
 
421
            if (!decoder->decode(elementTagName))
 
422
                return false;
 
423
            if (!decoder->decode(elementID))
 
424
                return false;
 
425
            Owner classNamesCoder(coder, elementClassNames);
 
426
            if (!decoder->decode(classNamesCoder))
 
427
                return false;
 
428
            if (!decoder->decode(absolutePosition))
 
429
                return false;
 
430
            if (!decoder->decode(frameRect))
 
431
                return false;
 
432
            Owner messageCoder(coder, children);
 
433
            if (!decoder->decode(messageCoder))
 
434
                return false;
 
435
            if (children && children->type() != APIObject::TypeArray)
 
436
                return false;
 
437
            coder.m_root = WebRenderObject::create(name, elementTagName, elementID, WTF::static_pointer_cast<MutableArray>(elementClassNames), absolutePosition, frameRect, WTF::static_pointer_cast<MutableArray>(children));
 
438
            break;
 
439
        }
 
440
        case APIObject::TypeURL: {
 
441
            String string;
 
442
            if (!decoder->decode(string))
 
443
                return false;
 
444
            coder.m_root = WebURL::create(string);
 
445
            break;
 
446
        }
 
447
        case APIObject::TypeURLRequest: {
 
448
            WebCore::ResourceRequest request;
 
449
            if (!decoder->decode(request))
 
450
                return false;
 
451
            coder.m_root = WebURLRequest::create(request);
 
452
            break;
 
453
        }
 
454
        case APIObject::TypeUserContentURLPattern: {
 
455
            String string;
 
456
            if (!decoder->decode(string))
 
457
                return false;
 
458
            coder.m_root = WebUserContentURLPattern::create(string);
 
459
            break;
 
460
        }
 
461
        case APIObject::TypeImage: {
 
462
            bool didEncode = false;
 
463
            if (!decoder->decode(didEncode))
 
464
                return false;
 
465
 
 
466
            if (!didEncode)
 
467
                break;
 
468
 
 
469
            ShareableBitmap::Handle handle;
 
470
            if (!decoder->decode(handle))
 
471
                return false;
 
472
 
 
473
            coder.m_root = WebImage::create(ShareableBitmap::create(handle));
 
474
            return true;
 
475
        }
 
476
        case APIObject::TypeData: {
 
477
            CoreIPC::DataReference dataReference;
 
478
            if (!decoder->decode(dataReference))
 
479
                return false;
 
480
            coder.m_root = WebData::create(dataReference.data(), dataReference.size());
 
481
            break;
 
482
        }
 
483
        case APIObject::TypeCertificateInfo: {
 
484
            PlatformCertificateInfo platformCertificateInfo;
 
485
            if (!decoder->decode(platformCertificateInfo))
 
486
                return false;
 
487
            coder.m_root = WebCertificateInfo::create(platformCertificateInfo);
 
488
            break;
 
489
        }
 
490
        default:
 
491
            break;
 
492
        }
 
493
 
 
494
        return true;
 
495
    }
 
496
 
 
497
protected:
 
498
    UserMessageDecoder(RefPtr<APIObject>& root)
 
499
        : m_root(root)
 
500
    {
 
501
    }
 
502
 
 
503
    RefPtr<APIObject>& m_root;
 
504
};
 
505
 
 
506
} // namespace WebKit
 
507
 
 
508
#endif // UserMessageCoders_h