1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "content/renderer/pepper/resource_converter.h"
6
7 #include "base/bind.h"
8 #include "base/message_loop/message_loop.h"
9 #include "content/public/renderer/renderer_ppapi_host.h"
10 #include "content/renderer/pepper/pepper_file_system_host.h"
11 #include "content/renderer/pepper/pepper_media_stream_audio_track_host.h"
12 #include "content/renderer/pepper/pepper_media_stream_video_track_host.h"
13 #include "ipc/ipc_message.h"
14 #include "ppapi/host/ppapi_host.h"
15 #include "ppapi/host/resource_host.h"
16 #include "ppapi/proxy/ppapi_messages.h"
17 #include "ppapi/shared_impl/resource_var.h"
18 #include "ppapi/shared_impl/scoped_pp_var.h"
19 #include "third_party/WebKit/public/platform/WebFileSystem.h"
20 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
21 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
22 #include "third_party/WebKit/public/web/WebDOMFileSystem.h"
23 #include "third_party/WebKit/public/web/WebDOMMediaStreamTrack.h"
24 #include "third_party/WebKit/public/web/WebLocalFrame.h"
25 #include "webkit/common/fileapi/file_system_util.h"
26
27 using ppapi::ResourceVar;
28
29 namespace content {
30 namespace {
31
FlushComplete(const base::Callback<void (bool)> & callback,const std::vector<scoped_refptr<content::HostResourceVar>> & browser_vars,const std::vector<int> & pending_host_ids)32 void FlushComplete(
33 const base::Callback<void(bool)>& callback,
34 const std::vector<scoped_refptr<content::HostResourceVar> >& browser_vars,
35 const std::vector<int>& pending_host_ids) {
36 CHECK(browser_vars.size() == pending_host_ids.size());
37 for (size_t i = 0; i < browser_vars.size(); ++i) {
38 browser_vars[i]->set_pending_browser_host_id(pending_host_ids[i]);
39 }
40 callback.Run(true);
41 }
42
43 // Converts a blink::WebFileSystem::Type to a PP_FileSystemType.
WebFileSystemTypeToPPAPI(blink::WebFileSystem::Type type)44 PP_FileSystemType WebFileSystemTypeToPPAPI(blink::WebFileSystem::Type type) {
45 switch (type) {
46 case blink::WebFileSystem::TypeTemporary:
47 return PP_FILESYSTEMTYPE_LOCALTEMPORARY;
48 case blink::WebFileSystem::TypePersistent:
49 return PP_FILESYSTEMTYPE_LOCALPERSISTENT;
50 case blink::WebFileSystem::TypeIsolated:
51 return PP_FILESYSTEMTYPE_ISOLATED;
52 case blink::WebFileSystem::TypeExternal:
53 return PP_FILESYSTEMTYPE_EXTERNAL;
54 default:
55 NOTREACHED();
56 return PP_FILESYSTEMTYPE_LOCALTEMPORARY;
57 }
58 }
59
60 // Converts a fileapi::FileSystemType to a blink::WebFileSystemType.
61 // Returns true on success, false if |type| does not correspond to a
62 // WebFileSystemType.
FileApiFileSystemTypeToWebFileSystemType(fileapi::FileSystemType type,blink::WebFileSystemType * result_type)63 bool FileApiFileSystemTypeToWebFileSystemType(
64 fileapi::FileSystemType type,
65 blink::WebFileSystemType* result_type) {
66 switch (type) {
67 case fileapi::kFileSystemTypeTemporary:
68 *result_type = blink::WebFileSystemTypeTemporary;
69 return true;
70 case fileapi::kFileSystemTypePersistent:
71 *result_type = blink::WebFileSystemTypePersistent;
72 return true;
73 case fileapi::kFileSystemTypeIsolated:
74 *result_type = blink::WebFileSystemTypeIsolated;
75 return true;
76 case fileapi::kFileSystemTypeExternal:
77 *result_type = blink::WebFileSystemTypeExternal;
78 return true;
79 default:
80 return false;
81 }
82 }
83
84 // Given a V8 value containing a DOMFileSystem, creates a resource host and
85 // returns the resource information for serialization.
86 // On error, false.
DOMFileSystemToResource(PP_Instance instance,RendererPpapiHost * host,const blink::WebDOMFileSystem & dom_file_system,int * pending_renderer_id,scoped_ptr<IPC::Message> * create_message,scoped_ptr<IPC::Message> * browser_host_create_message)87 bool DOMFileSystemToResource(
88 PP_Instance instance,
89 RendererPpapiHost* host,
90 const blink::WebDOMFileSystem& dom_file_system,
91 int* pending_renderer_id,
92 scoped_ptr<IPC::Message>* create_message,
93 scoped_ptr<IPC::Message>* browser_host_create_message) {
94 DCHECK(!dom_file_system.isNull());
95
96 PP_FileSystemType file_system_type =
97 WebFileSystemTypeToPPAPI(dom_file_system.type());
98 GURL root_url = dom_file_system.rootURL();
99
100 // Raw external file system access is not allowed, but external file system
101 // access through fileapi is allowed. (Without this check, there would be a
102 // CHECK failure in FileRefResource.)
103 if ((file_system_type == PP_FILESYSTEMTYPE_EXTERNAL) &&
104 (!root_url.is_valid())) {
105 return false;
106 }
107
108 *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
109 scoped_ptr<ppapi::host::ResourceHost>(new PepperFileSystemHost(
110 host, instance, 0, root_url, file_system_type)));
111 if (*pending_renderer_id == 0)
112 return false;
113
114 create_message->reset(
115 new PpapiPluginMsg_FileSystem_CreateFromPendingHost(file_system_type));
116
117 browser_host_create_message->reset(
118 new PpapiHostMsg_FileSystem_CreateFromRenderer(root_url.spec(),
119 file_system_type));
120 return true;
121 }
122
ResourceHostToDOMFileSystem(content::PepperFileSystemHost * file_system_host,v8::Handle<v8::Context> context,v8::Handle<v8::Value> * dom_file_system)123 bool ResourceHostToDOMFileSystem(
124 content::PepperFileSystemHost* file_system_host,
125 v8::Handle<v8::Context> context,
126 v8::Handle<v8::Value>* dom_file_system) {
127 GURL root_url = file_system_host->GetRootUrl();
128 GURL origin;
129 fileapi::FileSystemType type;
130 base::FilePath virtual_path;
131 fileapi::ParseFileSystemSchemeURL(root_url, &origin, &type, &virtual_path);
132
133 std::string name = fileapi::GetFileSystemName(origin, type);
134 blink::WebFileSystemType blink_type;
135 if (!FileApiFileSystemTypeToWebFileSystemType(type, &blink_type))
136 return false;
137 blink::WebLocalFrame* frame = blink::WebLocalFrame::frameForContext(context);
138 blink::WebDOMFileSystem web_dom_file_system = blink::WebDOMFileSystem::create(
139 frame,
140 blink_type,
141 blink::WebString::fromUTF8(name),
142 root_url,
143 blink::WebDOMFileSystem::SerializableTypeSerializable);
144 *dom_file_system =
145 web_dom_file_system.toV8Value(context->Global(), context->GetIsolate());
146 return true;
147 }
148
ResourceHostToDOMMediaStreamVideoTrack(content::PepperMediaStreamVideoTrackHost * host,v8::Handle<v8::Context> context,v8::Handle<v8::Value> * dom_video_track)149 bool ResourceHostToDOMMediaStreamVideoTrack(
150 content::PepperMediaStreamVideoTrackHost* host,
151 v8::Handle<v8::Context> context,
152 v8::Handle<v8::Value>* dom_video_track) {
153 // TODO(ronghuawu): Implement this once crbug/352219 is resolved.
154 // blink::WebMediaStreamTrack track = host->track();
155 // *dom_video_track = track.toV8Value();
156 return false;
157 }
158
DOMMediaStreamTrackToResource(PP_Instance instance,RendererPpapiHost * host,const blink::WebDOMMediaStreamTrack & dom_media_stream_track,int * pending_renderer_id,scoped_ptr<IPC::Message> * create_message)159 bool DOMMediaStreamTrackToResource(
160 PP_Instance instance,
161 RendererPpapiHost* host,
162 const blink::WebDOMMediaStreamTrack& dom_media_stream_track,
163 int* pending_renderer_id,
164 scoped_ptr<IPC::Message>* create_message) {
165 DCHECK(!dom_media_stream_track.isNull());
166 *pending_renderer_id = 0;
167 #if defined(ENABLE_WEBRTC)
168 const blink::WebMediaStreamTrack track = dom_media_stream_track.component();
169 const std::string id = track.source().id().utf8();
170
171 if (track.source().type() == blink::WebMediaStreamSource::TypeVideo) {
172 *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
173 scoped_ptr<ppapi::host::ResourceHost>(
174 new PepperMediaStreamVideoTrackHost(host, instance, 0, track)));
175 if (*pending_renderer_id == 0)
176 return false;
177
178 create_message->reset(
179 new PpapiPluginMsg_MediaStreamVideoTrack_CreateFromPendingHost(id));
180 return true;
181 } else if (track.source().type() == blink::WebMediaStreamSource::TypeAudio) {
182 *pending_renderer_id = host->GetPpapiHost()->AddPendingResourceHost(
183 scoped_ptr<ppapi::host::ResourceHost>(
184 new PepperMediaStreamAudioTrackHost(host, instance, 0, track)));
185 if (*pending_renderer_id == 0)
186 return false;
187
188 create_message->reset(
189 new PpapiPluginMsg_MediaStreamAudioTrack_CreateFromPendingHost(id));
190 return true;
191 }
192 #endif
193 return false;
194 }
195
196 } // namespace
197
~ResourceConverter()198 ResourceConverter::~ResourceConverter() {}
199
ResourceConverterImpl(PP_Instance instance,RendererPpapiHost * host)200 ResourceConverterImpl::ResourceConverterImpl(PP_Instance instance,
201 RendererPpapiHost* host)
202 : instance_(instance), host_(host) {}
203
~ResourceConverterImpl()204 ResourceConverterImpl::~ResourceConverterImpl() {
205 // Verify Flush() was called.
206 DCHECK(browser_host_create_messages_.empty());
207 DCHECK(browser_vars_.empty());
208 }
209
FromV8Value(v8::Handle<v8::Object> val,v8::Handle<v8::Context> context,PP_Var * result,bool * was_resource)210 bool ResourceConverterImpl::FromV8Value(v8::Handle<v8::Object> val,
211 v8::Handle<v8::Context> context,
212 PP_Var* result,
213 bool* was_resource) {
214 v8::Context::Scope context_scope(context);
215 v8::HandleScope handle_scope(context->GetIsolate());
216
217 *was_resource = false;
218
219 blink::WebDOMFileSystem dom_file_system =
220 blink::WebDOMFileSystem::fromV8Value(val);
221 if (!dom_file_system.isNull()) {
222 int pending_renderer_id;
223 scoped_ptr<IPC::Message> create_message;
224 scoped_ptr<IPC::Message> browser_host_create_message;
225 if (!DOMFileSystemToResource(instance_,
226 host_,
227 dom_file_system,
228 &pending_renderer_id,
229 &create_message,
230 &browser_host_create_message)) {
231 return false;
232 }
233 DCHECK(create_message);
234 DCHECK(browser_host_create_message);
235 scoped_refptr<HostResourceVar> result_var =
236 CreateResourceVarWithBrowserHost(
237 pending_renderer_id, *create_message, *browser_host_create_message);
238 *result = result_var->GetPPVar();
239 *was_resource = true;
240 return true;
241 }
242
243 blink::WebDOMMediaStreamTrack dom_media_stream_track =
244 blink::WebDOMMediaStreamTrack::fromV8Value(val);
245 if (!dom_media_stream_track.isNull()) {
246 int pending_renderer_id;
247 scoped_ptr<IPC::Message> create_message;
248 if (!DOMMediaStreamTrackToResource(instance_,
249 host_,
250 dom_media_stream_track,
251 &pending_renderer_id,
252 &create_message)) {
253 return false;
254 }
255 DCHECK(create_message);
256 scoped_refptr<HostResourceVar> result_var =
257 CreateResourceVar(pending_renderer_id, *create_message);
258 *result = result_var->GetPPVar();
259 *was_resource = true;
260 return true;
261 }
262
263 // The value was not convertible to a resource. Return true with
264 // |was_resource| set to false. As per the interface of FromV8Value, |result|
265 // may be left unmodified in this case.
266 return true;
267 }
268
Reset()269 void ResourceConverterImpl::Reset() {
270 browser_host_create_messages_.clear();
271 browser_vars_.clear();
272 }
273
NeedsFlush()274 bool ResourceConverterImpl::NeedsFlush() {
275 return !browser_host_create_messages_.empty();
276 }
277
Flush(const base::Callback<void (bool)> & callback)278 void ResourceConverterImpl::Flush(const base::Callback<void(bool)>& callback) {
279 host_->CreateBrowserResourceHosts(
280 instance_,
281 browser_host_create_messages_,
282 base::Bind(&FlushComplete, callback, browser_vars_));
283 browser_host_create_messages_.clear();
284 browser_vars_.clear();
285 }
286
ToV8Value(const PP_Var & var,v8::Handle<v8::Context> context,v8::Handle<v8::Value> * result)287 bool ResourceConverterImpl::ToV8Value(const PP_Var& var,
288 v8::Handle<v8::Context> context,
289 v8::Handle<v8::Value>* result) {
290 DCHECK(var.type == PP_VARTYPE_RESOURCE);
291
292 ResourceVar* resource = ResourceVar::FromPPVar(var);
293 if (!resource) {
294 NOTREACHED();
295 return false;
296 }
297 PP_Resource resource_id = resource->GetPPResource();
298
299 // Get the renderer-side resource host for this resource.
300 content::RendererPpapiHost* renderer_ppapi_host =
301 content::RendererPpapiHost::GetForPPInstance(instance_);
302 if (!renderer_ppapi_host) {
303 // This should never happen: the RendererPpapiHost is owned by the module
304 // and should outlive instances associated with it. However, if it doesn't
305 // for some reason, we do not want to crash.
306 NOTREACHED();
307 return false;
308 }
309 ::ppapi::host::PpapiHost* ppapi_host = renderer_ppapi_host->GetPpapiHost();
310 ::ppapi::host::ResourceHost* resource_host =
311 ppapi_host->GetResourceHost(resource_id);
312 if (resource_host == NULL) {
313 LOG(ERROR) << "No resource host for resource #" << resource_id;
314 return false;
315 }
316
317 // Convert to the appropriate type of resource host.
318 if (resource_host->IsFileSystemHost()) {
319 return ResourceHostToDOMFileSystem(
320 static_cast<content::PepperFileSystemHost*>(resource_host),
321 context,
322 result);
323 } else if (resource_host->IsMediaStreamVideoTrackHost()) {
324 return ResourceHostToDOMMediaStreamVideoTrack(
325 static_cast<content::PepperMediaStreamVideoTrackHost*>(resource_host),
326 context,
327 result);
328 } else {
329 LOG(ERROR) << "The type of resource #" << resource_id
330 << " cannot be converted to a JavaScript object.";
331 return false;
332 }
333 }
334
CreateResourceVar(int pending_renderer_id,const IPC::Message & create_message)335 scoped_refptr<HostResourceVar> ResourceConverterImpl::CreateResourceVar(
336 int pending_renderer_id,
337 const IPC::Message& create_message) {
338 return new HostResourceVar(pending_renderer_id, create_message);
339 }
340
341 scoped_refptr<HostResourceVar>
CreateResourceVarWithBrowserHost(int pending_renderer_id,const IPC::Message & create_message,const IPC::Message & browser_host_create_message)342 ResourceConverterImpl::CreateResourceVarWithBrowserHost(
343 int pending_renderer_id,
344 const IPC::Message& create_message,
345 const IPC::Message& browser_host_create_message) {
346 scoped_refptr<HostResourceVar> result =
347 CreateResourceVar(pending_renderer_id, create_message);
348 browser_host_create_messages_.push_back(browser_host_create_message);
349 browser_vars_.push_back(result);
350 return result;
351 }
352
353 } // namespace content
354