| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/pepper_file_io_host.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/callback.h" | |
| 9 #include "base/callback_helpers.h" | |
| 10 #include "base/command_line.h" | |
| 11 #include "base/files/file_util_proxy.h" | |
| 12 #include "content/child/child_thread.h" | |
| 13 #include "content/child/fileapi/file_system_dispatcher.h" | |
| 14 #include "content/child/quota_dispatcher.h" | |
| 15 #include "content/common/fileapi/file_system_messages.h" | |
| 16 #include "content/common/view_messages.h" | |
| 17 #include "content/public/common/content_client.h" | |
| 18 #include "content/public/renderer/content_renderer_client.h" | |
| 19 #include "content/renderer/pepper/pepper_file_ref_renderer_host.h" | |
| 20 #include "content/renderer/pepper/quota_file_io.h" | |
| 21 #include "content/renderer/pepper/renderer_ppapi_host_impl.h" | |
| 22 #include "content/renderer/render_thread_impl.h" | |
| 23 #include "ppapi/c/pp_errors.h" | |
| 24 #include "ppapi/c/ppb_file_io.h" | |
| 25 #include "ppapi/host/dispatch_host_message.h" | |
| 26 #include "ppapi/host/ppapi_host.h" | |
| 27 #include "ppapi/proxy/ppapi_messages.h" | |
| 28 #include "ppapi/shared_impl/file_type_conversion.h" | |
| 29 #include "ppapi/shared_impl/time_conversion.h" | |
| 30 #include "ppapi/thunk/enter.h" | |
| 31 #include "third_party/WebKit/public/web/WebPluginContainer.h" | |
| 32 | |
| 33 namespace content { | |
| 34 | |
| 35 using ppapi::FileIOStateManager; | |
| 36 using ppapi::PPTimeToTime; | |
| 37 using ppapi::host::ReplyMessageContext; | |
| 38 using ppapi::thunk::EnterResourceNoLock; | |
| 39 | |
| 40 namespace { | |
| 41 | |
| 42 typedef base::Callback<void (base::PlatformFileError)> PlatformGeneralCallback; | |
| 43 | |
| 44 int32_t ErrorOrByteNumber(int32_t pp_error, int32_t byte_number) { | |
| 45 // On the plugin side, some callbacks expect a parameter that means different | |
| 46 // things depending on whether is negative or not. We translate for those | |
| 47 // callbacks here. | |
| 48 return pp_error == PP_OK ? byte_number : pp_error; | |
| 49 } | |
| 50 | |
| 51 class QuotaCallbackTranslator : public QuotaDispatcher::Callback { | |
| 52 public: | |
| 53 typedef QuotaFileIO::Delegate::AvailableSpaceCallback PluginCallback; | |
| 54 explicit QuotaCallbackTranslator(const PluginCallback& cb) : callback_(cb) {} | |
| 55 virtual void DidQueryStorageUsageAndQuota(int64 usage, int64 quota) OVERRIDE { | |
| 56 callback_.Run(std::max(static_cast<int64>(0), quota - usage)); | |
| 57 } | |
| 58 virtual void DidGrantStorageQuota(int64 granted_quota) OVERRIDE { | |
| 59 NOTREACHED(); | |
| 60 } | |
| 61 virtual void DidFail(quota::QuotaStatusCode error) OVERRIDE { | |
| 62 callback_.Run(0); | |
| 63 } | |
| 64 private: | |
| 65 PluginCallback callback_; | |
| 66 }; | |
| 67 | |
| 68 class QuotaFileIODelegate : public QuotaFileIO::Delegate { | |
| 69 public: | |
| 70 QuotaFileIODelegate() {} | |
| 71 virtual ~QuotaFileIODelegate() {} | |
| 72 | |
| 73 virtual void QueryAvailableSpace( | |
| 74 const GURL& origin, | |
| 75 quota::StorageType type, | |
| 76 const AvailableSpaceCallback& callback) OVERRIDE { | |
| 77 ChildThread::current()->quota_dispatcher()->QueryStorageUsageAndQuota( | |
| 78 origin, type, new QuotaCallbackTranslator(callback)); | |
| 79 } | |
| 80 virtual void WillUpdateFile(const GURL& file_path) OVERRIDE { | |
| 81 ChildThread::current()->Send(new FileSystemHostMsg_WillUpdate(file_path)); | |
| 82 } | |
| 83 virtual void DidUpdateFile(const GURL& file_path, int64_t delta) OVERRIDE { | |
| 84 ChildThread::current()->Send(new FileSystemHostMsg_DidUpdate( | |
| 85 file_path, delta)); | |
| 86 } | |
| 87 virtual scoped_refptr<base::MessageLoopProxy> | |
| 88 GetFileThreadMessageLoopProxy() OVERRIDE { | |
| 89 return RenderThreadImpl::current()->GetFileThreadMessageLoopProxy(); | |
| 90 } | |
| 91 }; | |
| 92 | |
| 93 typedef base::Callback< | |
| 94 void (base::PlatformFileError error, | |
| 95 base::PassPlatformFile file, | |
| 96 quota::QuotaLimitType quota_policy, | |
| 97 const PepperFileIOHost::NotifyCloseFileCallback& close_file_callback)> | |
| 98 AsyncOpenFileSystemURLCallback; | |
| 99 | |
| 100 void DoNotifyCloseFile(int file_open_id, base::PlatformFileError error) { | |
| 101 ChildThread::current()->file_system_dispatcher()->NotifyCloseFile( | |
| 102 file_open_id); | |
| 103 } | |
| 104 | |
| 105 void DidOpenFileSystemURL(const AsyncOpenFileSystemURLCallback& callback, | |
| 106 base::PlatformFile file, | |
| 107 int file_open_id, | |
| 108 quota::QuotaLimitType quota_policy) { | |
| 109 callback.Run(base::PLATFORM_FILE_OK, | |
| 110 base::PassPlatformFile(&file), | |
| 111 quota_policy, | |
| 112 base::Bind(&DoNotifyCloseFile, file_open_id)); | |
| 113 // Make sure we won't leak file handle if the requester has died. | |
| 114 if (file != base::kInvalidPlatformFileValue) { | |
| 115 base::FileUtilProxy::Close( | |
| 116 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 117 file, | |
| 118 base::Bind(&DoNotifyCloseFile, file_open_id)); | |
| 119 } | |
| 120 } | |
| 121 | |
| 122 void DidFailOpenFileSystemURL(const AsyncOpenFileSystemURLCallback& callback, | |
| 123 base::PlatformFileError error_code) { | |
| 124 base::PlatformFile invalid_file = base::kInvalidPlatformFileValue; | |
| 125 callback.Run(error_code, | |
| 126 base::PassPlatformFile(&invalid_file), | |
| 127 quota::kQuotaLimitTypeUnknown, | |
| 128 PepperFileIOHost::NotifyCloseFileCallback()); | |
| 129 } | |
| 130 | |
| 131 } // namespace | |
| 132 | |
| 133 PepperFileIOHost::PepperFileIOHost(RendererPpapiHost* host, | |
| 134 PP_Instance instance, | |
| 135 PP_Resource resource) | |
| 136 : ResourceHost(host->GetPpapiHost(), instance, resource), | |
| 137 renderer_ppapi_host_(host), | |
| 138 file_(base::kInvalidPlatformFileValue), | |
| 139 file_system_type_(PP_FILESYSTEMTYPE_INVALID), | |
| 140 quota_policy_(quota::kQuotaLimitTypeUnknown), | |
| 141 open_flags_(0), | |
| 142 routing_id_(RenderThreadImpl::current()->GenerateRoutingID()), | |
| 143 weak_factory_(this) { | |
| 144 ChildThread::current()->AddRoute(routing_id_, this); | |
| 145 } | |
| 146 | |
| 147 PepperFileIOHost::~PepperFileIOHost() { | |
| 148 OnHostMsgClose(NULL); | |
| 149 ChildThread::current()->RemoveRoute(routing_id_); | |
| 150 } | |
| 151 | |
| 152 int32_t PepperFileIOHost::OnResourceMessageReceived( | |
| 153 const IPC::Message& msg, | |
| 154 ppapi::host::HostMessageContext* context) { | |
| 155 IPC_BEGIN_MESSAGE_MAP(PepperFileIOHost, msg) | |
| 156 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_Open, | |
| 157 OnHostMsgOpen) | |
| 158 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_Touch, | |
| 159 OnHostMsgTouch) | |
| 160 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_Write, | |
| 161 OnHostMsgWrite) | |
| 162 PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FileIO_SetLength, | |
| 163 OnHostMsgSetLength) | |
| 164 PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FileIO_Flush, | |
| 165 OnHostMsgFlush) | |
| 166 PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FileIO_Close, | |
| 167 OnHostMsgClose) | |
| 168 PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FileIO_RequestOSFileHandle, | |
| 169 OnHostMsgRequestOSFileHandle) | |
| 170 IPC_END_MESSAGE_MAP() | |
| 171 return PP_ERROR_FAILED; | |
| 172 } | |
| 173 | |
| 174 bool PepperFileIOHost::OnMessageReceived(const IPC::Message& msg) { | |
| 175 bool handled = true; | |
| 176 IPC_BEGIN_MESSAGE_MAP(PepperFileIOHost, msg) | |
| 177 IPC_MESSAGE_HANDLER(ViewMsg_AsyncOpenPepperFile_ACK, OnAsyncFileOpened) | |
| 178 IPC_MESSAGE_UNHANDLED(handled = false) | |
| 179 IPC_END_MESSAGE_MAP() | |
| 180 return handled; | |
| 181 } | |
| 182 | |
| 183 void PepperFileIOHost::OnAsyncFileOpened( | |
| 184 base::PlatformFileError error_code, | |
| 185 IPC::PlatformFileForTransit file_for_transit) { | |
| 186 DCHECK(!pending_open_callback_.is_null()); | |
| 187 base::PlatformFile file = | |
| 188 IPC::PlatformFileForTransitToPlatformFile(file_for_transit); | |
| 189 if (!pending_open_callback_.is_null()) | |
| 190 pending_open_callback_.Run(error_code, base::PassPlatformFile(&file)); | |
| 191 | |
| 192 // Make sure we won't leak file handle if the requester has died. | |
| 193 if (file != base::kInvalidPlatformFileValue) { | |
| 194 base::FileUtilProxy::Close( | |
| 195 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 196 file, | |
| 197 base::FileUtilProxy::StatusCallback()); | |
| 198 } | |
| 199 pending_open_callback_.Reset(); | |
| 200 } | |
| 201 | |
| 202 int32_t PepperFileIOHost::OnHostMsgOpen( | |
| 203 ppapi::host::HostMessageContext* context, | |
| 204 PP_Resource file_ref_resource, | |
| 205 int32_t open_flags) { | |
| 206 int32_t rv = state_manager_.CheckOperationState( | |
| 207 FileIOStateManager::OPERATION_EXCLUSIVE, false); | |
| 208 if (rv != PP_OK) | |
| 209 return rv; | |
| 210 | |
| 211 if (!ppapi::PepperFileOpenFlagsToPlatformFileFlags(open_flags, NULL)) | |
| 212 return PP_ERROR_BADARGUMENT; | |
| 213 | |
| 214 ppapi::host::ResourceHost* resource_host = | |
| 215 renderer_ppapi_host_->GetPpapiHost()->GetResourceHost(file_ref_resource); | |
| 216 if (!resource_host || !resource_host->IsFileRefHost()) | |
| 217 return PP_ERROR_BADRESOURCE; | |
| 218 | |
| 219 PepperFileRefRendererHost* file_ref_host = | |
| 220 static_cast<PepperFileRefRendererHost*>(resource_host); | |
| 221 if (file_ref_host->GetFileSystemType() == PP_FILESYSTEMTYPE_INVALID) | |
| 222 return PP_ERROR_FAILED; | |
| 223 | |
| 224 open_flags_ = open_flags; | |
| 225 file_system_type_ = file_ref_host->GetFileSystemType(); | |
| 226 | |
| 227 if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) { | |
| 228 file_system_url_ = file_ref_host->GetFileSystemURL(); | |
| 229 FileSystemDispatcher* file_system_dispatcher = | |
| 230 ChildThread::current()->file_system_dispatcher(); | |
| 231 | |
| 232 AsyncOpenFileSystemURLCallback callback = base::Bind( | |
| 233 &PepperFileIOHost::ExecutePlatformOpenFileSystemURLCallback, | |
| 234 weak_factory_.GetWeakPtr(), | |
| 235 context->MakeReplyMessageContext()); | |
| 236 file_system_dispatcher->OpenPepperFile( | |
| 237 file_system_url_, open_flags, | |
| 238 base::Bind(&DidOpenFileSystemURL, callback), | |
| 239 base::Bind(&DidFailOpenFileSystemURL, callback)); | |
| 240 } else { | |
| 241 pending_open_callback_ = | |
| 242 base::Bind(&PepperFileIOHost::ExecutePlatformOpenFileCallback, | |
| 243 weak_factory_.GetWeakPtr(), | |
| 244 context->MakeReplyMessageContext()); | |
| 245 RenderThreadImpl::current()->Send(new ViewHostMsg_AsyncOpenPepperFile( | |
| 246 routing_id_, | |
| 247 file_ref_host->GetExternalFilePath(), | |
| 248 open_flags_)); | |
| 249 } | |
| 250 state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); | |
| 251 return PP_OK_COMPLETIONPENDING; | |
| 252 } | |
| 253 | |
| 254 int32_t PepperFileIOHost::OnHostMsgTouch( | |
| 255 ppapi::host::HostMessageContext* context, | |
| 256 PP_Time last_access_time, | |
| 257 PP_Time last_modified_time) { | |
| 258 int32_t rv = state_manager_.CheckOperationState( | |
| 259 FileIOStateManager::OPERATION_EXCLUSIVE, true); | |
| 260 if (rv != PP_OK) | |
| 261 return rv; | |
| 262 | |
| 263 if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) { | |
| 264 FileSystemDispatcher* file_system_dispatcher = | |
| 265 ChildThread::current()->file_system_dispatcher(); | |
| 266 file_system_dispatcher->TouchFile( | |
| 267 file_system_url_, | |
| 268 PPTimeToTime(last_access_time), | |
| 269 PPTimeToTime(last_modified_time), | |
| 270 base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback, | |
| 271 weak_factory_.GetWeakPtr(), | |
| 272 context->MakeReplyMessageContext())); | |
| 273 state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); | |
| 274 return PP_OK_COMPLETIONPENDING; | |
| 275 } | |
| 276 | |
| 277 // TODO(nhiroki): fix a failure of FileIO.Touch for an external filesystem on | |
| 278 // Mac and Linux due to sandbox restrictions (http://crbug.com/101128). | |
| 279 if (!base::FileUtilProxy::Touch( | |
| 280 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 281 file_, | |
| 282 PPTimeToTime(last_access_time), | |
| 283 PPTimeToTime(last_modified_time), | |
| 284 base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback, | |
| 285 weak_factory_.GetWeakPtr(), | |
| 286 context->MakeReplyMessageContext()))) | |
| 287 return PP_ERROR_FAILED; | |
| 288 | |
| 289 state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); | |
| 290 return PP_OK_COMPLETIONPENDING; | |
| 291 } | |
| 292 | |
| 293 int32_t PepperFileIOHost::OnHostMsgWrite( | |
| 294 ppapi::host::HostMessageContext* context, | |
| 295 int64_t offset, | |
| 296 const std::string& buffer) { | |
| 297 int32_t rv = state_manager_.CheckOperationState( | |
| 298 FileIOStateManager::OPERATION_WRITE, true); | |
| 299 if (rv != PP_OK) | |
| 300 return rv; | |
| 301 | |
| 302 if (quota_file_io_) { | |
| 303 if (!quota_file_io_->Write( | |
| 304 offset, buffer.c_str(), buffer.size(), | |
| 305 base::Bind(&PepperFileIOHost::ExecutePlatformWriteCallback, | |
| 306 weak_factory_.GetWeakPtr(), | |
| 307 context->MakeReplyMessageContext()))) | |
| 308 return PP_ERROR_FAILED; | |
| 309 } else { | |
| 310 if (!base::FileUtilProxy::Write( | |
| 311 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 312 file_, | |
| 313 offset, | |
| 314 buffer.c_str(), | |
| 315 buffer.size(), | |
| 316 base::Bind(&PepperFileIOHost::ExecutePlatformWriteCallback, | |
| 317 weak_factory_.GetWeakPtr(), | |
| 318 context->MakeReplyMessageContext()))) | |
| 319 return PP_ERROR_FAILED; | |
| 320 } | |
| 321 | |
| 322 state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_WRITE); | |
| 323 return PP_OK_COMPLETIONPENDING; | |
| 324 } | |
| 325 | |
| 326 int32_t PepperFileIOHost::OnHostMsgSetLength( | |
| 327 ppapi::host::HostMessageContext* context, | |
| 328 int64_t length) { | |
| 329 int32_t rv = state_manager_.CheckOperationState( | |
| 330 FileIOStateManager::OPERATION_EXCLUSIVE, true); | |
| 331 if (rv != PP_OK) | |
| 332 return rv; | |
| 333 | |
| 334 if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) { | |
| 335 FileSystemDispatcher* file_system_dispatcher = | |
| 336 ChildThread::current()->file_system_dispatcher(); | |
| 337 file_system_dispatcher->Truncate( | |
| 338 file_system_url_, length, NULL, | |
| 339 base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback, | |
| 340 weak_factory_.GetWeakPtr(), | |
| 341 context->MakeReplyMessageContext())); | |
| 342 } else { | |
| 343 // TODO(nhiroki): fix a failure of FileIO.SetLength for an external | |
| 344 // filesystem on Mac due to sandbox restrictions (http://crbug.com/156077). | |
| 345 if (!base::FileUtilProxy::Truncate( | |
| 346 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 347 file_, | |
| 348 length, | |
| 349 base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback, | |
| 350 weak_factory_.GetWeakPtr(), | |
| 351 context->MakeReplyMessageContext()))) | |
| 352 return PP_ERROR_FAILED; | |
| 353 } | |
| 354 | |
| 355 state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); | |
| 356 return PP_OK_COMPLETIONPENDING; | |
| 357 } | |
| 358 | |
| 359 int32_t PepperFileIOHost::OnHostMsgFlush( | |
| 360 ppapi::host::HostMessageContext* context) { | |
| 361 int32_t rv = state_manager_.CheckOperationState( | |
| 362 FileIOStateManager::OPERATION_EXCLUSIVE, true); | |
| 363 if (rv != PP_OK) | |
| 364 return rv; | |
| 365 | |
| 366 if (!base::FileUtilProxy::Flush( | |
| 367 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 368 file_, | |
| 369 base::Bind(&PepperFileIOHost::ExecutePlatformGeneralCallback, | |
| 370 weak_factory_.GetWeakPtr(), | |
| 371 context->MakeReplyMessageContext()))) | |
| 372 return PP_ERROR_FAILED; | |
| 373 | |
| 374 state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); | |
| 375 return PP_OK_COMPLETIONPENDING; | |
| 376 } | |
| 377 | |
| 378 int32_t PepperFileIOHost::OnHostMsgClose( | |
| 379 ppapi::host::HostMessageContext* context) { | |
| 380 if (file_ != base::kInvalidPlatformFileValue) { | |
| 381 base::FileUtilProxy::Close( | |
| 382 RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), | |
| 383 file_, | |
| 384 base::ResetAndReturn(¬ify_close_file_callback_)); | |
| 385 file_ = base::kInvalidPlatformFileValue; | |
| 386 quota_file_io_.reset(); | |
| 387 } | |
| 388 return PP_OK; | |
| 389 } | |
| 390 | |
| 391 int32_t PepperFileIOHost::OnHostMsgRequestOSFileHandle( | |
| 392 ppapi::host::HostMessageContext* context) { | |
| 393 if (open_flags_ != PP_FILEOPENFLAG_READ && | |
| 394 quota_policy_ != quota::kQuotaLimitTypeUnlimited) | |
| 395 return PP_ERROR_FAILED; | |
| 396 | |
| 397 // Whitelist to make it privately accessible. | |
| 398 if (!host()->permissions().HasPermission(ppapi::PERMISSION_PRIVATE) && | |
| 399 !GetContentClient()->renderer()->IsPluginAllowedToCallRequestOSFileHandle( | |
| 400 renderer_ppapi_host_->GetContainerForInstance(pp_instance()))) | |
| 401 return PP_ERROR_NOACCESS; | |
| 402 | |
| 403 IPC::PlatformFileForTransit file = | |
| 404 renderer_ppapi_host_->ShareHandleWithRemote(file_, false); | |
| 405 if (file == IPC::InvalidPlatformFileForTransit()) | |
| 406 return PP_ERROR_FAILED; | |
| 407 ppapi::host::ReplyMessageContext reply_context = | |
| 408 context->MakeReplyMessageContext(); | |
| 409 ppapi::proxy::SerializedHandle file_handle; | |
| 410 file_handle.set_file_handle(file, open_flags_); | |
| 411 reply_context.params.AppendHandle(file_handle); | |
| 412 host()->SendReply(reply_context, | |
| 413 PpapiPluginMsg_FileIO_RequestOSFileHandleReply()); | |
| 414 return PP_OK_COMPLETIONPENDING; | |
| 415 } | |
| 416 | |
| 417 void PepperFileIOHost::ExecutePlatformGeneralCallback( | |
| 418 ppapi::host::ReplyMessageContext reply_context, | |
| 419 base::PlatformFileError error_code) { | |
| 420 reply_context.params.set_result( | |
| 421 ppapi::PlatformFileErrorToPepperError(error_code)); | |
| 422 host()->SendReply(reply_context, PpapiPluginMsg_FileIO_GeneralReply()); | |
| 423 state_manager_.SetOperationFinished(); | |
| 424 } | |
| 425 | |
| 426 void PepperFileIOHost::ExecutePlatformOpenFileCallback( | |
| 427 ppapi::host::ReplyMessageContext reply_context, | |
| 428 base::PlatformFileError error_code, | |
| 429 base::PassPlatformFile file) { | |
| 430 int32_t pp_error = ppapi::PlatformFileErrorToPepperError(error_code); | |
| 431 if (pp_error == PP_OK) | |
| 432 state_manager_.SetOpenSucceed(); | |
| 433 | |
| 434 DCHECK(file_ == base::kInvalidPlatformFileValue); | |
| 435 file_ = file.ReleaseValue(); | |
| 436 | |
| 437 DCHECK(!quota_file_io_.get()); | |
| 438 if (file_ != base::kInvalidPlatformFileValue) { | |
| 439 if (file_system_type_ == PP_FILESYSTEMTYPE_LOCALTEMPORARY || | |
| 440 file_system_type_ == PP_FILESYSTEMTYPE_LOCALPERSISTENT) { | |
| 441 quota_file_io_.reset(new QuotaFileIO( | |
| 442 new QuotaFileIODelegate, file_, file_system_url_, file_system_type_)); | |
| 443 } | |
| 444 | |
| 445 IPC::PlatformFileForTransit file_for_transit = | |
| 446 renderer_ppapi_host_->ShareHandleWithRemote(file_, false); | |
| 447 if (!(file_for_transit == IPC::InvalidPlatformFileForTransit())) { | |
| 448 // Send the file descriptor to the plugin process. This is used in the | |
| 449 // plugin for any file operations that can be done there. | |
| 450 int32_t flags_to_send = open_flags_; | |
| 451 if (!host()->permissions().HasPermission(ppapi::PERMISSION_DEV)) { | |
| 452 // IMPORTANT: Clear PP_FILEOPENFLAG_WRITE and PP_FILEOPENFLAG_APPEND so | |
| 453 // the plugin can't write and so bypass our quota checks. | |
| 454 flags_to_send = | |
| 455 open_flags_ & ~(PP_FILEOPENFLAG_WRITE | PP_FILEOPENFLAG_APPEND); | |
| 456 } | |
| 457 ppapi::proxy::SerializedHandle file_handle; | |
| 458 file_handle.set_file_handle(file_for_transit, flags_to_send); | |
| 459 reply_context.params.AppendHandle(file_handle); | |
| 460 } | |
| 461 } | |
| 462 | |
| 463 reply_context.params.set_result(pp_error); | |
| 464 host()->SendReply(reply_context, PpapiPluginMsg_FileIO_OpenReply()); | |
| 465 state_manager_.SetOperationFinished(); | |
| 466 } | |
| 467 | |
| 468 void PepperFileIOHost::ExecutePlatformOpenFileSystemURLCallback( | |
| 469 ppapi::host::ReplyMessageContext reply_context, | |
| 470 base::PlatformFileError error_code, | |
| 471 base::PassPlatformFile file, | |
| 472 quota::QuotaLimitType quota_policy, | |
| 473 const PepperFileIOHost::NotifyCloseFileCallback& callback) { | |
| 474 if (error_code == base::PLATFORM_FILE_OK) | |
| 475 notify_close_file_callback_ = callback; | |
| 476 quota_policy_ = quota_policy; | |
| 477 ExecutePlatformOpenFileCallback(reply_context, error_code, file); | |
| 478 } | |
| 479 | |
| 480 void PepperFileIOHost::ExecutePlatformWriteCallback( | |
| 481 ppapi::host::ReplyMessageContext reply_context, | |
| 482 base::PlatformFileError error_code, | |
| 483 int bytes_written) { | |
| 484 // On the plugin side, the callback expects a parameter with different meaning | |
| 485 // depends on whether is negative or not. It is the result here. We translate | |
| 486 // for the callback. | |
| 487 int32_t pp_error = ppapi::PlatformFileErrorToPepperError(error_code); | |
| 488 reply_context.params.set_result(ErrorOrByteNumber(pp_error, bytes_written)); | |
| 489 host()->SendReply(reply_context, PpapiPluginMsg_FileIO_GeneralReply()); | |
| 490 state_manager_.SetOperationFinished(); | |
| 491 } | |
| 492 | |
| 493 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 33053002:
Pepper: Move FileIO host from renderer to browser. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src