1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ppapi/proxy/ppb_graphics_2d_proxy.h"
#include <string.h> // For memset
#include "base/logging.h"
#include "ppapi/c/pp_completion_callback.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/c/pp_resource.h"
#include "ppapi/c/ppb_graphics_2d.h"
#include "ppapi/proxy/plugin_dispatcher.h"
#include "ppapi/proxy/plugin_resource.h"
#include "ppapi/proxy/ppapi_messages.h"
namespace pp {
namespace proxy {
class Graphics2D : public PluginResource {
public:
Graphics2D(const PP_Size& size, PP_Bool is_always_opaque)
: size_(size), is_always_opaque_(is_always_opaque) {
}
// Resource overrides.
virtual Graphics2D* AsGraphics2D() { return this; }
const PP_Size& size() const { return size_; }
PP_Bool is_always_opaque() const { return is_always_opaque_; }
private:
PP_Size size_;
PP_Bool is_always_opaque_;
DISALLOW_COPY_AND_ASSIGN(Graphics2D);
};
namespace {
PP_Resource Create(PP_Module module_id,
const PP_Size* size,
PP_Bool is_always_opaque) {
PluginDispatcher* dispatcher = PluginDispatcher::Get();
PP_Resource result = 0;
dispatcher->Send(new PpapiHostMsg_PPBGraphics2D_Create(
INTERFACE_ID_PPB_GRAPHICS_2D, module_id, *size, is_always_opaque,
&result));
if (result) {
linked_ptr<Graphics2D> graphics_2d(new Graphics2D(*size, is_always_opaque));
dispatcher->plugin_resource_tracker()->AddResource(result, graphics_2d);
}
return result;
}
PP_Bool IsGraphics2D(PP_Resource resource) {
Graphics2D* object = PluginResource::GetAs<Graphics2D>(resource);
return BoolToPPBool(!!object);
}
PP_Bool Describe(PP_Resource graphics_2d,
PP_Size* size,
PP_Bool* is_always_opaque) {
Graphics2D* object = PluginResource::GetAs<Graphics2D>(graphics_2d);
if (!object) {
size->width = 0;
size->height = 0;
*is_always_opaque = PP_FALSE;
return PP_FALSE;
}
*size = object->size();
*is_always_opaque = object->is_always_opaque();
return PP_TRUE;
}
void PaintImageData(PP_Resource graphics_2d,
PP_Resource image_data,
const PP_Point* top_left,
const PP_Rect* src_rect) {
PP_Rect dummy;
memset(&dummy, 0, sizeof(PP_Rect));
PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBGraphics2D_PaintImageData(
INTERFACE_ID_PPB_GRAPHICS_2D, graphics_2d, image_data, *top_left,
!!src_rect, src_rect ? *src_rect : dummy));
}
void Scroll(PP_Resource graphics_2d,
const PP_Rect* clip_rect,
const PP_Point* amount) {
PP_Rect dummy;
memset(&dummy, 0, sizeof(PP_Rect));
PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBGraphics2D_Scroll(
INTERFACE_ID_PPB_GRAPHICS_2D, graphics_2d, !!clip_rect,
clip_rect ? *clip_rect : dummy, *amount));
}
void ReplaceContents(PP_Resource graphics_2d, PP_Resource image_data) {
PluginDispatcher::Get()->Send(new PpapiHostMsg_PPBGraphics2D_ReplaceContents(
INTERFACE_ID_PPB_GRAPHICS_2D, graphics_2d, image_data));
}
int32_t Flush(PP_Resource graphics_2d,
PP_CompletionCallback callback) {
PluginDispatcher* dispatcher = PluginDispatcher::Get();
int32_t result = PP_ERROR_FAILED;
dispatcher->Send(new PpapiHostMsg_PPBGraphics2D_Flush(
INTERFACE_ID_PPB_GRAPHICS_2D, graphics_2d,
dispatcher->callback_tracker().SendCallback(callback),
&result));
return result;
}
const PPB_Graphics2D ppb_graphics_2d = {
&Create,
&IsGraphics2D,
&Describe,
&PaintImageData,
&Scroll,
&ReplaceContents,
&Flush
};
} // namespace
PPB_Graphics2D_Proxy::PPB_Graphics2D_Proxy(Dispatcher* dispatcher,
const void* target_interface)
: InterfaceProxy(dispatcher, target_interface) {
}
PPB_Graphics2D_Proxy::~PPB_Graphics2D_Proxy() {
}
const void* PPB_Graphics2D_Proxy::GetSourceInterface() const {
return &ppb_graphics_2d;
}
InterfaceID PPB_Graphics2D_Proxy::GetInterfaceId() const {
return INTERFACE_ID_PPB_GRAPHICS_2D;
}
void PPB_Graphics2D_Proxy::OnMessageReceived(const IPC::Message& msg) {
IPC_BEGIN_MESSAGE_MAP(PPB_Graphics2D_Proxy, msg)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Create,
OnMsgCreate)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_PaintImageData,
OnMsgPaintImageData)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Scroll,
OnMsgScroll)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_ReplaceContents,
OnMsgReplaceContents)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics2D_Flush,
OnMsgFlush)
IPC_END_MESSAGE_MAP()
// FIXME(brettw) handle bad messages!
}
void PPB_Graphics2D_Proxy::OnMsgCreate(PP_Module module,
const PP_Size& size,
PP_Bool is_always_opaque,
PP_Resource* result) {
*result = ppb_graphics_2d_target()->Create(
module, &size, is_always_opaque);
}
void PPB_Graphics2D_Proxy::OnMsgPaintImageData(PP_Resource graphics_2d,
PP_Resource image_data,
const PP_Point& top_left,
bool src_rect_specified,
const PP_Rect& src_rect) {
ppb_graphics_2d_target()->PaintImageData(
graphics_2d, image_data, &top_left,
src_rect_specified ? &src_rect : NULL);
}
void PPB_Graphics2D_Proxy::OnMsgScroll(PP_Resource graphics_2d,
bool clip_specified,
const PP_Rect& clip,
const PP_Point& amount) {
ppb_graphics_2d_target()->Scroll(
graphics_2d,
clip_specified ? &clip : NULL, &amount);
}
void PPB_Graphics2D_Proxy::OnMsgReplaceContents(PP_Resource graphics_2d,
PP_Resource image_data) {
ppb_graphics_2d_target()->ReplaceContents(graphics_2d, image_data);
}
void PPB_Graphics2D_Proxy::OnMsgFlush(PP_Resource graphics_2d,
uint32_t serialized_callback,
int32_t* result) {
// TODO(brettw) this should be a non-sync function. Ideally it would call
// the callback with a failure code from here if you weren't allowed to
// call Flush there.
*result = ppb_graphics_2d_target()->Flush(
graphics_2d, ReceiveCallback(serialized_callback));
}
} // namespace proxy
} // namespace pp
|
