← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Source/WebKit2/UIProcess/GenericCallback.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/UIProcess/GenericCallback.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 GenericCallback_h
 
27
#define GenericCallback_h
 
28
 
 
29
#include "ShareableBitmap.h"
 
30
#include "WKAPICast.h"
 
31
#include "WebError.h"
 
32
#include <wtf/HashMap.h>
 
33
#include <wtf/PassRefPtr.h>
 
34
#include <wtf/RefCounted.h>
 
35
 
 
36
namespace WebKit {
 
37
 
 
38
class CallbackBase : public RefCounted<CallbackBase> {
 
39
public:
 
40
    virtual ~CallbackBase()
 
41
    {
 
42
    }
 
43
 
 
44
    uint64_t callbackID() const { return m_callbackID; }
 
45
 
 
46
protected:
 
47
    explicit CallbackBase(void* context)
 
48
        : m_context(context)
 
49
        , m_callbackID(generateCallbackID())
 
50
    {
 
51
    }
 
52
 
 
53
    void* context() const { return m_context; }
 
54
 
 
55
private:
 
56
    static uint64_t generateCallbackID()
 
57
    {
 
58
        static uint64_t uniqueCallbackID = 1;
 
59
        return uniqueCallbackID++;
 
60
    }
 
61
 
 
62
    void* m_context;
 
63
    uint64_t m_callbackID;
 
64
};
 
65
 
 
66
class VoidCallback : public CallbackBase {
 
67
public:
 
68
    typedef void (*CallbackFunction)(WKErrorRef, void*);
 
69
 
 
70
    static PassRefPtr<VoidCallback> create(void* context, CallbackFunction callback)
 
71
    {
 
72
        return adoptRef(new VoidCallback(context, callback));
 
73
    }
 
74
 
 
75
    virtual ~VoidCallback()
 
76
    {
 
77
        ASSERT(!m_callback);
 
78
    }
 
79
 
 
80
    void performCallback()
 
81
    {
 
82
        ASSERT(m_callback);
 
83
 
 
84
        m_callback(0, context());
 
85
 
 
86
        m_callback = 0;
 
87
    }
 
88
    
 
89
    void invalidate()
 
90
    {
 
91
        ASSERT(m_callback);
 
92
 
 
93
        RefPtr<WebError> error = WebError::create();
 
94
        m_callback(toAPI(error.get()), context());
 
95
        
 
96
        m_callback = 0;
 
97
    }
 
98
 
 
99
private:
 
100
    VoidCallback(void* context, CallbackFunction callback)
 
101
        : CallbackBase(context)
 
102
        , m_callback(callback)
 
103
    {
 
104
    }
 
105
 
 
106
    CallbackFunction m_callback;
 
107
};
 
108
 
 
109
template<typename APIReturnValueType, typename InternalReturnValueType = typename APITypeInfo<APIReturnValueType>::ImplType>
 
110
class GenericCallback : public CallbackBase {
 
111
public:
 
112
    typedef void (*CallbackFunction)(APIReturnValueType, WKErrorRef, void*);
 
113
 
 
114
    static PassRefPtr<GenericCallback> create(void* context, CallbackFunction callback)
 
115
    {
 
116
        return adoptRef(new GenericCallback(context, callback));
 
117
    }
 
118
 
 
119
    virtual ~GenericCallback()
 
120
    {
 
121
        ASSERT(!m_callback);
 
122
    }
 
123
 
 
124
    void performCallbackWithReturnValue(InternalReturnValueType returnValue)
 
125
    {
 
126
        ASSERT(m_callback);
 
127
 
 
128
        m_callback(toAPI(returnValue), 0, context());
 
129
 
 
130
        m_callback = 0;
 
131
    }
 
132
    
 
133
    void invalidate()
 
134
    {
 
135
        ASSERT(m_callback);
 
136
 
 
137
        RefPtr<WebError> error = WebError::create();
 
138
        m_callback(0, toAPI(error.get()), context());
 
139
        
 
140
        m_callback = 0;
 
141
    }
 
142
 
 
143
private:
 
144
    GenericCallback(void* context, CallbackFunction callback)
 
145
        : CallbackBase(context)
 
146
        , m_callback(callback)
 
147
    {
 
148
    }
 
149
 
 
150
    CallbackFunction m_callback;
 
151
};
 
152
 
 
153
// FIXME: Make a version of CallbackBase with two arguments, and define ComputedPagesCallback as a specialization.
 
154
class ComputedPagesCallback : public CallbackBase {
 
155
public:
 
156
    typedef void (*CallbackFunction)(const Vector<WebCore::IntRect>&, double, WKErrorRef, void*);
 
157
 
 
158
    static PassRefPtr<ComputedPagesCallback> create(void* context, CallbackFunction callback)
 
159
    {
 
160
        return adoptRef(new ComputedPagesCallback(context, callback));
 
161
    }
 
162
 
 
163
    virtual ~ComputedPagesCallback()
 
164
    {
 
165
        ASSERT(!m_callback);
 
166
    }
 
167
 
 
168
    void performCallbackWithReturnValue(const Vector<WebCore::IntRect>& returnValue1, double returnValue2)
 
169
    {
 
170
        ASSERT(m_callback);
 
171
 
 
172
        m_callback(returnValue1, returnValue2, 0, context());
 
173
 
 
174
        m_callback = 0;
 
175
    }
 
176
    
 
177
    void invalidate()
 
178
    {
 
179
        ASSERT(m_callback);
 
180
 
 
181
        RefPtr<WebError> error = WebError::create();
 
182
        m_callback(Vector<WebCore::IntRect>(), 0, toAPI(error.get()), context());
 
183
        
 
184
        m_callback = 0;
 
185
    }
 
186
 
 
187
private:
 
188
 
 
189
    ComputedPagesCallback(void* context, CallbackFunction callback)
 
190
        : CallbackBase(context)
 
191
        , m_callback(callback)
 
192
    {
 
193
    }
 
194
 
 
195
    CallbackFunction m_callback;
 
196
};
 
197
 
 
198
class ImageCallback : public CallbackBase {
 
199
public:
 
200
    typedef void (*CallbackFunction)(const ShareableBitmap::Handle&, WKErrorRef, void*);
 
201
 
 
202
    static PassRefPtr<ImageCallback> create(void* context, CallbackFunction callback)
 
203
    {
 
204
        return adoptRef(new ImageCallback(context, callback));
 
205
    }
 
206
 
 
207
    virtual ~ImageCallback()
 
208
    {
 
209
        ASSERT(!m_callback);
 
210
    }
 
211
 
 
212
    void performCallbackWithReturnValue(const ShareableBitmap::Handle& returnValue1)
 
213
    {
 
214
        ASSERT(m_callback);
 
215
 
 
216
        m_callback(returnValue1, 0, context());
 
217
 
 
218
        m_callback = 0;
 
219
    }
 
220
 
 
221
    void invalidate()
 
222
    {
 
223
        ASSERT(m_callback);
 
224
 
 
225
        RefPtr<WebError> error = WebError::create();
 
226
        ShareableBitmap::Handle handle;
 
227
        m_callback(handle, toAPI(error.get()), context());
 
228
 
 
229
        m_callback = 0;
 
230
    }
 
231
 
 
232
private:
 
233
 
 
234
    ImageCallback(void* context, CallbackFunction callback)
 
235
        : CallbackBase(context)
 
236
        , m_callback(callback)
 
237
    {
 
238
    }
 
239
    
 
240
    CallbackFunction m_callback;
 
241
};
 
242
 
 
243
template<typename T>
 
244
void invalidateCallbackMap(HashMap<uint64_t, T>& map)
 
245
{
 
246
    Vector<T> callbacksVector;
 
247
    copyValuesToVector(map, callbacksVector);
 
248
    for (size_t i = 0, size = callbacksVector.size(); i < size; ++i)
 
249
        callbacksVector[i]->invalidate();
 
250
    map.clear();
 
251
}
 
252
 
 
253
} // namespace WebKit
 
254
 
 
255
#endif // GenericCallback_h