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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ppapi/proxy/ppb_buffer_proxy.h"
#include <vector>
#include "base/notreached.h"
#include "build/build_config.h"
#include "ppapi/c/dev/ppb_buffer_dev.h"
#include "ppapi/c/pp_completion_callback.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/c/pp_resource.h"
#include "ppapi/proxy/host_dispatcher.h"
#include "ppapi/proxy/plugin_dispatcher.h"
#include "ppapi/proxy/ppapi_messages.h"
#include "ppapi/thunk/enter.h"
#include "ppapi/thunk/resource_creation_api.h"
#include "ppapi/thunk/thunk.h"
namespace ppapi {
namespace proxy {
Buffer::Buffer(const HostResource& resource,
base::UnsafeSharedMemoryRegion shm_region)
: Resource(OBJECT_IS_PROXY, resource),
shm_(std::move(shm_region)),
map_count_(0) {}
Buffer::~Buffer() {
Unmap();
}
thunk::PPB_Buffer_API* Buffer::AsPPB_Buffer_API() {
return this;
}
PP_Bool Buffer::Describe(uint32_t* size_in_bytes) {
*size_in_bytes = shm_.GetSize();
return PP_TRUE;
}
PP_Bool Buffer::IsMapped() {
return PP_FromBool(map_count_ > 0);
}
void* Buffer::Map() {
if (map_count_++ == 0)
mapping_ = shm_.Map();
return mapping_.memory();
}
void Buffer::Unmap() {
if (--map_count_ == 0)
mapping_ = {};
}
int32_t Buffer::GetSharedMemory(base::UnsafeSharedMemoryRegion** out_handle) {
NOTREACHED();
}
PPB_Buffer_Proxy::PPB_Buffer_Proxy(Dispatcher* dispatcher)
: InterfaceProxy(dispatcher) {
}
PPB_Buffer_Proxy::~PPB_Buffer_Proxy() {
}
// static
PP_Resource PPB_Buffer_Proxy::CreateProxyResource(PP_Instance instance,
uint32_t size) {
PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
if (!dispatcher)
return 0;
HostResource result;
ppapi::proxy::SerializedHandle shm_handle;
dispatcher->Send(new PpapiHostMsg_PPBBuffer_Create(
API_ID_PPB_BUFFER, instance, size, &result, &shm_handle));
if (result.is_null() || !shm_handle.IsHandleValid() ||
!shm_handle.is_shmem_region())
return 0;
return AddProxyResource(result, base::UnsafeSharedMemoryRegion::Deserialize(
shm_handle.TakeSharedMemoryRegion()));
}
// static
PP_Resource PPB_Buffer_Proxy::AddProxyResource(
const HostResource& resource,
base::UnsafeSharedMemoryRegion shm_region) {
return (new Buffer(resource, std::move(shm_region)))->GetReference();
}
bool PPB_Buffer_Proxy::OnMessageReceived(const IPC::Message& msg) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(PPB_Buffer_Proxy, msg)
IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBBuffer_Create, OnMsgCreate)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
// TODO(brettw) handle bad messages!
return handled;
}
void PPB_Buffer_Proxy::OnMsgCreate(
PP_Instance instance,
uint32_t size,
HostResource* result_resource,
ppapi::proxy::SerializedHandle* result_shm_handle) {
// Overwritten below on success.
result_shm_handle->set_null_shmem_region();
HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
if (!dispatcher)
return;
if (!dispatcher->permissions().HasPermission(ppapi::PERMISSION_DEV))
return;
thunk::EnterResourceCreation enter(instance);
if (enter.failed())
return;
PP_Resource local_buffer_resource = enter.functions()->CreateBuffer(instance,
size);
if (local_buffer_resource == 0)
return;
thunk::EnterResourceNoLock<thunk::PPB_Buffer_API> trusted_buffer(
local_buffer_resource, false);
if (trusted_buffer.failed())
return;
base::UnsafeSharedMemoryRegion* local_shm;
if (trusted_buffer.object()->GetSharedMemory(&local_shm) != PP_OK)
return;
result_resource->SetHostResource(instance, local_buffer_resource);
result_shm_handle->set_unsafe_shmem_region(
dispatcher->ShareUnsafeSharedMemoryRegionWithRemote(*local_shm));
}
} // namespace proxy
} // namespace ppapi
|
