diff options
author | teravest@chromium.org <teravest@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-08-20 20:09:10 +0000 |
---|---|---|
committer | teravest@chromium.org <teravest@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2013-08-20 20:09:10 +0000 |
commit | 1407fe0bba44171c9365ed31238b698bf4d8e9c3 (patch) | |
tree | 2c85afd23f0cc634734ebe85d2ada40bd192ac28 | |
parent | 24994bc283803b411198dfd55009ad613bc0084d (diff) | |
download | chromium_src-1407fe0bba44171c9365ed31238b698bf4d8e9c3.zip chromium_src-1407fe0bba44171c9365ed31238b698bf4d8e9c3.tar.gz chromium_src-1407fe0bba44171c9365ed31238b698bf4d8e9c3.tar.bz2 |
Revert 218305 "Pepper: Move FileRef to the "new" resource proxy."
This change is being reverted because it was causing some crashes for an
application that I haven't been able to debug yet.
> Pepper: Move FileRef to the "new" resource proxy.
>
> This change moves the FileRef implementation from the previous one in the "old"
> resource model (ppb_file_ref_impl.cc) to the "new" resource model
> (pepper_file_ref_host.cc), and from the renderer to the browser.
>
> As many as possible of the supporting changes were split off to other changes
> to minimize the size of this change. Unfortunately, a lot of changes for
> URLLoader had to be rolled into this change.
>
> The data structures for CreateInfo have changed, and all users of FileRef have
> to be moved over, which is what causes this change to be so large.
>
> TBR=dmichael@chromium.org, jschuh@chromium.org, yzshen@chromium.org
> BUG=225441
>
> Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=216744
>
> Review URL: https://chromiumcodereview.appspot.com/21966004
TBR=teravest@chromium.org
Review URL: https://codereview.chromium.org/22901012
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@218544 0039d316-1c4b-4281-b951-d872f2087c98
67 files changed, 2010 insertions, 522 deletions
diff --git a/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc b/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc index 7f2011c..ca59c7ef 100644 --- a/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc +++ b/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc @@ -12,6 +12,7 @@ #include "ppapi/host/host_message_context.h" #include "ppapi/host/ppapi_host.h" #include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" namespace chrome { @@ -27,8 +28,7 @@ PepperFlashDRMRendererHost::PepperFlashDRMRendererHost( PP_Instance instance, PP_Resource resource) : ResourceHost(host->GetPpapiHost(), instance, resource), - renderer_ppapi_host_(host), - weak_factory_(this) { + renderer_ppapi_host_(host) { } PepperFlashDRMRendererHost::~PepperFlashDRMRendererHost() { @@ -56,26 +56,13 @@ int32_t PepperFlashDRMRendererHost::OnGetVoucherFile( base::FilePath voucher_file = plugin_dir.Append( base::FilePath(kVoucherFilename)); - renderer_ppapi_host_->CreateBrowserResourceHost( - pp_instance(), - PpapiHostMsg_FileRef_CreateExternal(voucher_file), - base::Bind(&PepperFlashDRMRendererHost::DidCreateFileRefHost, - weak_factory_.GetWeakPtr(), - context->MakeReplyMessageContext(), - voucher_file)); - return PP_OK_COMPLETIONPENDING; -} - -void PepperFlashDRMRendererHost::DidCreateFileRefHost( - const ppapi::host::ReplyMessageContext& reply_context, - const base::FilePath& external_path, - int pending_resource_id) { - ppapi::FileRefCreateInfo create_info = - ppapi::MakeExternalFileRefCreateInfo(external_path, - std::string(), - pending_resource_id); - host()->SendReply(reply_context, - PpapiPluginMsg_FlashDRM_GetVoucherFileReply(create_info)); + ppapi::PPB_FileRef_CreateInfo create_info; + ppapi::proxy::PPB_FileRef_Proxy::SerializeFileRef( + plugin_instance->CreateExternalFileReference(voucher_file), + &create_info); + context->reply_msg = + PpapiPluginMsg_FlashDRM_GetVoucherFileReply(create_info); + return PP_OK; } } // namespace chrome diff --git a/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h b/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h index a0382b6..f7247d6 100644 --- a/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h +++ b/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h @@ -7,13 +7,8 @@ #include "base/basictypes.h" #include "base/compiler_specific.h" -#include "base/memory/weak_ptr.h" #include "ppapi/host/resource_host.h" -namespace base { -class FilePath; -} - namespace content { class RendererPpapiHost; } @@ -36,16 +31,9 @@ class PepperFlashDRMRendererHost : public ppapi::host::ResourceHost { private: int32_t OnGetVoucherFile(ppapi::host::HostMessageContext* context); - void DidCreateFileRefHost( - const ppapi::host::ReplyMessageContext& reply_context, - const base::FilePath& external_path, - int pending_resource_id); - // Non-owning pointer. content::RendererPpapiHost* renderer_ppapi_host_; - base::WeakPtrFactory<PepperFlashDRMRendererHost> weak_factory_; - DISALLOW_COPY_AND_ASSIGN(PepperFlashDRMRendererHost); }; diff --git a/content/browser/renderer_host/pepper/pepper_external_file_ref_backend.cc b/content/browser/renderer_host/pepper/pepper_external_file_ref_backend.cc index 2bd44c1..27ba37d 100644 --- a/content/browser/renderer_host/pepper/pepper_external_file_ref_backend.cc +++ b/content/browser/renderer_host/pepper/pepper_external_file_ref_backend.cc @@ -90,10 +90,7 @@ int32_t PepperExternalFileRefBackend::GetAbsolutePath( ppapi::host::ReplyMessageContext reply_context) { host_->SendReply(reply_context, PpapiPluginMsg_FileRef_GetAbsolutePathReply(path_.AsUTF8Unsafe())); - - // Use PP_OK_COMPLETIONPENDING instead of PP_OK since we've already sent our - // reply above. - return PP_OK_COMPLETIONPENDING; + return PP_OK; } fileapi::FileSystemURL PepperExternalFileRefBackend::GetFileSystemURL() const { diff --git a/content/browser/renderer_host/pepper/pepper_file_ref_host.cc b/content/browser/renderer_host/pepper/pepper_file_ref_host.cc index 32ef0ac..5370af9 100644 --- a/content/browser/renderer_host/pepper/pepper_file_ref_host.cc +++ b/content/browser/renderer_host/pepper/pepper_file_ref_host.cc @@ -62,9 +62,9 @@ PepperFileRefHost::PepperFileRefHost(BrowserPpapiHost* host, } fs_type_ = fs_host->GetType(); + // TODO(teravest): Add support for isolated filesystems. if ((fs_type_ != PP_FILESYSTEMTYPE_LOCALPERSISTENT) && - (fs_type_ != PP_FILESYSTEMTYPE_LOCALTEMPORARY) && - (fs_type_ != PP_FILESYSTEMTYPE_ISOLATED)) { + (fs_type_ != PP_FILESYSTEMTYPE_LOCALTEMPORARY)) { DLOG(ERROR) << "Unsupported filesystem type: " << fs_type_; return; } diff --git a/content/browser/renderer_host/pepper/pepper_internal_file_ref_backend.cc b/content/browser/renderer_host/pepper/pepper_internal_file_ref_backend.cc index 2d93123..337807d 100644 --- a/content/browser/renderer_host/pepper/pepper_internal_file_ref_backend.cc +++ b/content/browser/renderer_host/pepper/pepper_internal_file_ref_backend.cc @@ -221,7 +221,7 @@ void PepperInternalFileRefBackend::ReadDirectoryComplete( context.params.set_result(ppapi::PlatformFileErrorToPepperError(error)); - std::vector<ppapi::FileRefCreateInfo> infos; + std::vector<ppapi::FileRef_CreateInfo> infos; std::vector<PP_FileType> file_types; if (error == base::PLATFORM_FILE_OK && fs_host_.get()) { std::string dir_path = path_; @@ -235,7 +235,7 @@ void PepperInternalFileRefBackend::ReadDirectoryComplete( else file_types.push_back(PP_FILETYPE_REGULAR); - ppapi::FileRefCreateInfo info; + ppapi::FileRef_CreateInfo info; info.file_system_type = fs_type_; info.file_system_plugin_resource = fs_host_->pp_resource(); std::string path = diff --git a/content/browser/renderer_host/pepper/pepper_renderer_connection.cc b/content/browser/renderer_host/pepper/pepper_renderer_connection.cc index 7e3428a..a5b95ce 100644 --- a/content/browser/renderer_host/pepper/pepper_renderer_connection.cc +++ b/content/browser/renderer_host/pepper/pepper_renderer_connection.cc @@ -16,9 +16,7 @@ #include "ppapi/host/resource_host.h" #include "ppapi/proxy/ppapi_message_utils.h" #include "ppapi/proxy/ppapi_messages.h" -#include "ppapi/proxy/ppapi_message_utils.h" #include "ppapi/proxy/resource_message_params.h" -#include "ppapi/shared_impl/file_ref_detailed_info.h" namespace content { @@ -78,8 +76,6 @@ bool PepperRendererConnection::OnMessageReceived(const IPC::Message& msg, OnMsgCreateResourceHostFromHost) IPC_MESSAGE_HANDLER(PpapiHostMsg_FileRef_GetInfoForRenderer, OnMsgFileRefGetInfoForRenderer) - IPC_MESSAGE_HANDLER(PpapiHostMsg_FileRef_SyncGetInfoForRenderer, - OnMsgFileRefSyncGetInfoForRenderer) IPC_MESSAGE_HANDLER(ViewHostMsg_DidCreateInProcessInstance, OnMsgDidCreateInProcessInstance) IPC_MESSAGE_HANDLER(ViewHostMsg_DidDeleteInProcessInstance, @@ -136,20 +132,12 @@ void PepperRendererConnection::OnMsgFileRefGetInfoForRenderer( int child_process_id, int32_t sequence, const std::vector<PP_Resource>& resources) { - std::vector<ppapi::FileRefDetailedInfo> infos; - OnMsgFileRefSyncGetInfoForRenderer(child_process_id, resources, &infos); - Send(new PpapiHostMsg_FileRef_GetInfoForRendererReply( - routing_id, - sequence, - infos)); -} + std::vector<PP_Resource> out_resources; + std::vector<PP_FileSystemType> fs_types; + std::vector<std::string> file_system_url_specs; + std::vector<base::FilePath> external_paths; -void PepperRendererConnection::OnMsgFileRefSyncGetInfoForRenderer( - int child_process_id, - const std::vector<PP_Resource>& resources, - std::vector<ppapi::FileRefDetailedInfo>* out_infos) { BrowserPpapiHostImpl* host = GetHostForChildProcess(child_process_id); - if (host) { for (size_t i = 0; i < resources.size(); ++i) { ppapi::host::ResourceHost* resource_host = @@ -157,15 +145,20 @@ void PepperRendererConnection::OnMsgFileRefSyncGetInfoForRenderer( if (resource_host && resource_host->IsFileRefHost()) { PepperFileRefHost* file_ref_host = static_cast<PepperFileRefHost*>(resource_host); - ppapi::FileRefDetailedInfo info; - info.resource = resources[i]; - info.file_system_type = file_ref_host->GetFileSystemType(); - info.file_system_url_spec = file_ref_host->GetFileSystemURLSpec(); - info.external_path = file_ref_host->GetExternalPath(); - out_infos->push_back(info); + out_resources.push_back(resources[i]); + fs_types.push_back(file_ref_host->GetFileSystemType()); + file_system_url_specs.push_back(file_ref_host->GetFileSystemURLSpec()); + external_paths.push_back(file_ref_host->GetExternalPath()); } } } + Send(new PpapiHostMsg_FileRef_GetInfoForRendererReply( + routing_id, + sequence, + out_resources, + fs_types, + file_system_url_specs, + external_paths)); } void PepperRendererConnection::OnMsgDidCreateInProcessInstance( diff --git a/content/browser/renderer_host/pepper/pepper_renderer_connection.h b/content/browser/renderer_host/pepper/pepper_renderer_connection.h index 074bef6..4392346 100644 --- a/content/browser/renderer_host/pepper/pepper_renderer_connection.h +++ b/content/browser/renderer_host/pepper/pepper_renderer_connection.h @@ -11,7 +11,6 @@ #include "content/public/browser/browser_message_filter.h" #include "ppapi/c/pp_instance.h" #include "ppapi/c/pp_resource.h" -#include "ppapi/shared_impl/file_ref_detailed_info.h" class GURL; @@ -59,11 +58,6 @@ class PepperRendererConnection : public BrowserMessageFilter { int32_t sequence_num, const std::vector<PP_Resource>& resources); - void OnMsgFileRefSyncGetInfoForRenderer( - int child_process_id, - const std::vector<PP_Resource>& resources, - std::vector<ppapi::FileRefDetailedInfo>* out_infos); - void OnMsgDidCreateInProcessInstance( PP_Instance instance, const PepperRendererInstanceData& instance_data); diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi index ece9006..7d4f7d0 100644 --- a/content/content_renderer.gypi +++ b/content/content_renderer.gypi @@ -355,6 +355,8 @@ 'renderer/pepper/ppb_broker_impl.h', 'renderer/pepper/ppb_buffer_impl.cc', 'renderer/pepper/ppb_buffer_impl.h', + 'renderer/pepper/ppb_file_ref_impl.cc', + 'renderer/pepper/ppb_file_ref_impl.h', 'renderer/pepper/ppb_flash_message_loop_impl.cc', 'renderer/pepper/ppb_flash_message_loop_impl.h', 'renderer/pepper/ppb_graphics_3d_impl.cc', diff --git a/content/public/renderer/pepper_plugin_instance.h b/content/public/renderer/pepper_plugin_instance.h index c7741a2..211752d 100644 --- a/content/public/renderer/pepper_plugin_instance.h +++ b/content/public/renderer/pepper_plugin_instance.h @@ -56,6 +56,11 @@ class PepperPluginInstance { // Returns the location of this module. virtual base::FilePath GetModulePath() = 0; + // Returns a reference to a file with the given path. + // The returned object will have a refcount of 0 (just like "new"). + virtual PP_Resource CreateExternalFileReference( + const base::FilePath& external_file_path) = 0; + // Creates a PPB_ImageData given a Skia image. virtual PP_Resource CreateImage(gfx::ImageSkia* source_image, float scale) = 0; @@ -87,6 +92,7 @@ class PepperPluginInstance { virtual int32_t Navigate(const ppapi::URLRequestInfoData& request, const char* target, bool from_user_action) = 0; + }; } // namespace content diff --git a/content/public/renderer/renderer_ppapi_host.h b/content/public/renderer/renderer_ppapi_host.h index 36d6273..329961e 100644 --- a/content/public/renderer/renderer_ppapi_host.h +++ b/content/public/renderer/renderer_ppapi_host.h @@ -47,11 +47,6 @@ class RendererPpapiHost { public: // Returns the RendererPpapiHost associated with the given PP_Instance, // or NULL if the instance is invalid. - // - // Do NOT use this when dealing with the "NaCl trusted plugin". That plugin - // and the "untrusted plugin" (the NaCl application) that will be loaded - // share a PP_Instance, and the RendererPpapiHost* for the "untrusted plugin" - // will be returned after we switch the proxy on. CONTENT_EXPORT static RendererPpapiHost* GetForPPInstance( PP_Instance instance); diff --git a/content/renderer/pepper/mock_renderer_ppapi_host.cc b/content/renderer/pepper/mock_renderer_ppapi_host.cc index 70b8281..e1de551 100644 --- a/content/renderer/pepper/mock_renderer_ppapi_host.cc +++ b/content/renderer/pepper/mock_renderer_ppapi_host.cc @@ -82,6 +82,7 @@ void MockRendererPpapiHost::CreateBrowserResourceHost( PP_Instance instance, const IPC::Message& nested_msg, const base::Callback<void(int)>& callback) const { + NOTIMPLEMENTED(); callback.Run(0); return; } diff --git a/content/renderer/pepper/pepper_browser_connection.cc b/content/renderer/pepper/pepper_browser_connection.cc index 00c6cd6..3032576 100644 --- a/content/renderer/pepper/pepper_browser_connection.cc +++ b/content/renderer/pepper/pepper_browser_connection.cc @@ -34,10 +34,9 @@ bool PepperBrowserConnection::OnMessageReceived(const IPC::Message& msg) { IPC_BEGIN_MESSAGE_MAP(PepperBrowserConnection, msg) IPC_MESSAGE_HANDLER(PpapiHostMsg_CreateResourceHostFromHostReply, OnMsgCreateResourceHostFromHostReply) - IPC_MESSAGE_HANDLER(PpapiHostMsg_FileRef_GetInfoForRendererReply, - OnMsgFileRefGetInfoReply) IPC_MESSAGE_UNHANDLED(handled = false) IPC_END_MESSAGE_MAP() + return handled; } @@ -102,7 +101,10 @@ void PepperBrowserConnection::OnMsgCreateResourceHostFromHostReply( void PepperBrowserConnection::OnMsgFileRefGetInfoReply( int32_t sequence_number, - const std::vector<ppapi::FileRefDetailedInfo>& infos) { + const std::vector<PP_Resource>& resources, + const std::vector<PP_FileSystemType>& types, + const std::vector<std::string>& file_system_url_specs, + const std::vector<base::FilePath>& external_paths) { // Check that the message is destined for the plugin this object is associated // with. std::map<int32_t, FileRefGetInfoCallback>::iterator it = @@ -110,7 +112,7 @@ void PepperBrowserConnection::OnMsgFileRefGetInfoReply( if (it != get_info_map_.end()) { FileRefGetInfoCallback callback = it->second; get_info_map_.erase(it); - callback.Run(infos); + callback.Run(resources, types, file_system_url_specs, external_paths); } else { NOTREACHED(); } diff --git a/content/renderer/pepper/pepper_browser_connection.h b/content/renderer/pepper/pepper_browser_connection.h index d058a32..9fde7d2 100644 --- a/content/renderer/pepper/pepper_browser_connection.h +++ b/content/renderer/pepper/pepper_browser_connection.h @@ -15,7 +15,6 @@ #include "ppapi/c/pp_file_info.h" #include "ppapi/c/pp_instance.h" #include "ppapi/c/pp_resource.h" -#include "ppapi/shared_impl/file_ref_detailed_info.h" namespace content { @@ -29,7 +28,10 @@ class PepperBrowserConnection public: typedef base::Callback<void(int)> PendingResourceIDCallback; typedef base::Callback<void( - const std::vector<ppapi::FileRefDetailedInfo>&)> FileRefGetInfoCallback; + const std::vector<PP_Resource>&, + const std::vector<PP_FileSystemType>&, + const std::vector<std::string>&, + const std::vector<base::FilePath>&)> FileRefGetInfoCallback; explicit PepperBrowserConnection(RenderView* render_view); virtual ~PepperBrowserConnection(); @@ -69,7 +71,10 @@ class PepperBrowserConnection int pending_resource_host_id); void OnMsgFileRefGetInfoReply( int32_t sequence_number, - const std::vector<ppapi::FileRefDetailedInfo>& infos); + const std::vector<PP_Resource>& resources, + const std::vector<PP_FileSystemType>& types, + const std::vector<std::string>& file_system_url_specs, + const std::vector<base::FilePath>& external_paths); // Return the next sequence number. int32_t GetNextSequence(); diff --git a/content/renderer/pepper/pepper_file_chooser_host.cc b/content/renderer/pepper/pepper_file_chooser_host.cc index bdf9cd8..1229d17 100644 --- a/content/renderer/pepper/pepper_file_chooser_host.cc +++ b/content/renderer/pepper/pepper_file_chooser_host.cc @@ -7,11 +7,13 @@ #include "base/files/file_path.h" #include "base/strings/utf_string_conversions.h" #include "content/public/renderer/renderer_ppapi_host.h" +#include "content/renderer/pepper/ppb_file_ref_impl.h" #include "content/renderer/render_view_impl.h" #include "ppapi/c/pp_errors.h" #include "ppapi/host/dispatch_host_message.h" #include "ppapi/host/ppapi_host.h" #include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" #include "third_party/WebKit/public/platform/WebCString.h" #include "third_party/WebKit/public/platform/WebString.h" #include "third_party/WebKit/public/platform/WebVector.h" @@ -79,9 +81,7 @@ PepperFileChooserHost::PepperFileChooserHost( PP_Resource resource) : ResourceHost(host->GetPpapiHost(), instance, resource), renderer_ppapi_host_(host), - num_pending_file_resources_(0), - handler_(NULL), - weak_factory_(this) { + handler_(NULL) { } PepperFileChooserHost::~PepperFileChooserHost() { @@ -98,30 +98,29 @@ int32_t PepperFileChooserHost::OnResourceMessageReceived( void PepperFileChooserHost::StoreChosenFiles( const std::vector<ChosenFileInfo>& files) { - num_pending_file_resources_ = files.size(); + std::vector<ppapi::PPB_FileRef_CreateInfo> chosen_files; for (size_t i = 0; i < files.size(); i++) { #if defined(OS_WIN) base::FilePath file_path(UTF8ToWide(files[i].path)); #else base::FilePath file_path(files[i].path); #endif - renderer_ppapi_host_->CreateBrowserResourceHost( - pp_instance(), - PpapiHostMsg_FileRef_CreateExternal(file_path), - base::Bind(&PepperFileChooserHost::DidCreateResourceHost, - weak_factory_.GetWeakPtr(), - file_path, - files[i].display_name)); - } - if (files.empty()) { - reply_context_.params.set_result(PP_ERROR_USERCANCEL); - std::vector<ppapi::FileRefCreateInfo> chosen_files; - host()->SendReply(reply_context_, - PpapiPluginMsg_FileChooser_ShowReply(chosen_files)); - reply_context_ = ppapi::host::ReplyMessageContext(); - handler_ = NULL; // Handler deletes itself. + PPB_FileRef_Impl* ref = PPB_FileRef_Impl::CreateExternal( + pp_instance(), file_path, files[i].display_name); + ppapi::PPB_FileRef_CreateInfo create_info; + ppapi::proxy::PPB_FileRef_Proxy::SerializeFileRef(ref->GetReference(), + &create_info); + chosen_files.push_back(create_info); } + + reply_context_.params.set_result( + (chosen_files.size() > 0) ? PP_OK : PP_ERROR_USERCANCEL); + host()->SendReply(reply_context_, + PpapiPluginMsg_FileChooser_ShowReply(chosen_files)); + + reply_context_ = ppapi::host::ReplyMessageContext(); + handler_ = NULL; // Handler deletes itself. } int32_t PepperFileChooserHost::OnShow( @@ -168,22 +167,5 @@ int32_t PepperFileChooserHost::OnShow( return PP_OK_COMPLETIONPENDING; } -void PepperFileChooserHost::DidCreateResourceHost( - const base::FilePath& file_path, - const std::string& display_name, - int32_t id) { - num_pending_file_resources_--; - ppapi::FileRefCreateInfo info = ppapi::MakeExternalFileRefCreateInfo( - file_path, display_name, id); - chosen_files_.push_back(info); - if (num_pending_file_resources_ == 0) { - reply_context_.params.set_result(PP_OK); - host()->SendReply(reply_context_, - PpapiPluginMsg_FileChooser_ShowReply(chosen_files_)); - reply_context_ = ppapi::host::ReplyMessageContext(); - handler_ = NULL; // Handler deletes itself. - } -} - } // namespace content diff --git a/content/renderer/pepper/pepper_file_chooser_host.h b/content/renderer/pepper/pepper_file_chooser_host.h index d837460..af27768 100644 --- a/content/renderer/pepper/pepper_file_chooser_host.h +++ b/content/renderer/pepper/pepper_file_chooser_host.h @@ -15,10 +15,6 @@ #include "ppapi/host/resource_host.h" #include "ppapi/proxy/resource_message_params.h" -namespace ppapi { -struct FileRefCreateInfo; -} - namespace content { class RendererPpapiHost; @@ -55,21 +51,12 @@ class CONTENT_EXPORT PepperFileChooserHost const std::string& suggested_file_name, const std::vector<std::string>& accept_mime_types); - void DidCreateResourceHost(const base::FilePath& file_path, - const std::string& display_name, - int32_t id); - // Non-owning pointer. RendererPpapiHost* renderer_ppapi_host_; - int num_pending_file_resources_; - std::vector<ppapi::FileRefCreateInfo> chosen_files_; - ppapi::host::ReplyMessageContext reply_context_; CompletionHandler* handler_; - base::WeakPtrFactory<PepperFileChooserHost> weak_factory_; - DISALLOW_COPY_AND_ASSIGN(PepperFileChooserHost); }; diff --git a/content/renderer/pepper/pepper_file_chooser_host_unittest.cc b/content/renderer/pepper/pepper_file_chooser_host_unittest.cc index 98c8598..b228cd7 100644 --- a/content/renderer/pepper/pepper_file_chooser_host_unittest.cc +++ b/content/renderer/pepper/pepper_file_chooser_host_unittest.cc @@ -17,8 +17,8 @@ #include "ppapi/proxy/ppapi_messages.h" #include "ppapi/proxy/resource_message_params.h" #include "ppapi/proxy/resource_message_test_sink.h" -#include "ppapi/shared_impl/file_ref_create_info.h" #include "ppapi/shared_impl/ppapi_permissions.h" +#include "ppapi/shared_impl/ppb_file_ref_shared.h" #include "ppapi/shared_impl/resource_tracker.h" #include "ppapi/shared_impl/test_globals.h" #include "testing/gtest/include/gtest/gtest.h" @@ -121,11 +121,13 @@ TEST_F(PepperFileChooserHostTest, Show) { PpapiPluginMsg_FileChooser_ShowReply::Schema::Param reply_msg_param; ASSERT_TRUE(PpapiPluginMsg_FileChooser_ShowReply::Read(&reply_msg, &reply_msg_param)); - const std::vector<ppapi::FileRefCreateInfo>& chooser_results = + const std::vector<ppapi::PPB_FileRef_CreateInfo>& chooser_results = reply_msg_param.a; ASSERT_EQ(1u, chooser_results.size()); + // Note path is empty because this is an external filesystem. + EXPECT_EQ(std::string(), chooser_results[0].path); EXPECT_EQ(FilePathToUTF8(selected_info.display_name), - chooser_results[0].display_name); + chooser_results[0].name); } TEST_F(PepperFileChooserHostTest, NoUserGesture) { diff --git a/content/renderer/pepper/pepper_file_io_host.cc b/content/renderer/pepper/pepper_file_io_host.cc index 0698f96..6b9cfc5 100644 --- a/content/renderer/pepper/pepper_file_io_host.cc +++ b/content/renderer/pepper/pepper_file_io_host.cc @@ -17,11 +17,9 @@ #include "content/public/common/content_client.h" #include "content/public/renderer/content_renderer_client.h" #include "content/renderer/pepper/host_globals.h" -#include "content/renderer/pepper/pepper_browser_connection.h" #include "content/renderer/pepper/pepper_plugin_instance_impl.h" -#include "content/renderer/pepper/plugin_module.h" +#include "content/renderer/pepper/ppb_file_ref_impl.h" #include "content/renderer/pepper/quota_file_io.h" -#include "content/renderer/pepper/renderer_ppapi_host_impl.h" #include "content/renderer/render_thread_impl.h" #include "ppapi/c/pp_errors.h" #include "ppapi/c/ppb_file_io.h" @@ -39,6 +37,7 @@ using ppapi::FileIOStateManager; using ppapi::PPTimeToTime; using ppapi::host::ReplyMessageContext; using ppapi::thunk::EnterResourceNoLock; +using ppapi::thunk::PPB_FileRef_API; namespace { @@ -138,7 +137,6 @@ PepperFileIOHost::PepperFileIOHost(RendererPpapiHost* host, PP_Resource resource) : ResourceHost(host->GetPpapiHost(), instance, resource), renderer_ppapi_host_(host), - plugin_instance_(HostGlobals::Get()->GetInstance(instance)), file_(base::kInvalidPlatformFileValue), file_system_type_(PP_FILESYSTEMTYPE_INVALID), quota_policy_(quota::kQuotaLimitTypeUnknown), @@ -231,66 +229,46 @@ int32_t PepperFileIOHost::OnHostMsgOpen( return PP_ERROR_BADARGUMENT; } - RenderView* render_view = - renderer_ppapi_host_->GetRenderViewForInstance(pp_instance()); - PepperBrowserConnection* browser_connection = - PepperBrowserConnection::Get(render_view); - int child_process_id = plugin_instance_->module()->GetPluginChildId(); - - // Explicitly set child_process_id to 0 if we're running in process. This is - // necessary in the case where we're a host for a resource in "the trusted - // NaCl plugin". In that case, we may have already done work for the - // untrusted plugin, and the call above will give a non-zero - // child_process_id. - if (renderer_ppapi_host_->IsRunningInProcess()) - child_process_id = 0; - - std::vector<PP_Resource> resources; - resources.push_back(file_ref_resource); - browser_connection->SendBrowserFileRefGetInfo( - child_process_id, - resources, - base::Bind(&PepperFileIOHost::DidGetFileRefInfo, - weak_factory_.GetWeakPtr(), - context->MakeReplyMessageContext(), - platform_file_flags)); - state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); - return PP_OK_COMPLETIONPENDING; -} + EnterResourceNoLock<PPB_FileRef_API> enter(file_ref_resource, true); + if (enter.failed()) + return PP_ERROR_BADRESOURCE; -void PepperFileIOHost::DidGetFileRefInfo( - ppapi::host::ReplyMessageContext reply_context, - int platform_file_flags, - const std::vector<ppapi::FileRefDetailedInfo>& infos) { - if (infos.size() != 1) { - reply_context.params.set_result(PP_ERROR_FAILED); - host()->SendReply(reply_context, - PpapiPluginMsg_FileIO_OpenReply()); - return; - } + PPB_FileRef_API* file_ref_api = enter.object(); + PP_FileSystemType type = file_ref_api->GetFileSystemType(); + if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT && + type != PP_FILESYSTEMTYPE_LOCALTEMPORARY && + type != PP_FILESYSTEMTYPE_EXTERNAL && + type != PP_FILESYSTEMTYPE_ISOLATED) + return PP_ERROR_FAILED; + file_system_type_ = type; + + PPB_FileRef_Impl* file_ref = static_cast<PPB_FileRef_Impl*>(file_ref_api); + if (file_ref->HasValidFileSystem()) { + file_system_url_ = file_ref->GetFileSystemURL(); - file_system_type_ = infos[0].file_system_type; - if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) { - file_system_url_ = GURL(infos[0].file_system_url_spec); FileSystemDispatcher* file_system_dispatcher = ChildThread::current()->file_system_dispatcher(); - AsyncOpenFileSystemURLCallback callback = base::Bind( &PepperFileIOHost::ExecutePlatformOpenFileSystemURLCallback, weak_factory_.GetWeakPtr(), - reply_context); + context->MakeReplyMessageContext()); file_system_dispatcher->OpenFile( file_system_url_, platform_file_flags, base::Bind(&DidOpenFileSystemURL, callback), base::Bind(&DidFailOpenFileSystemURL, callback)); } else { + if (file_system_type_ != PP_FILESYSTEMTYPE_EXTERNAL) + return PP_ERROR_FAILED; int message_id = pending_async_open_files_.Add(new AsyncOpenFileCallback( base::Bind(&PepperFileIOHost::ExecutePlatformOpenFileCallback, weak_factory_.GetWeakPtr(), - reply_context))); + context->MakeReplyMessageContext()))); RenderThreadImpl::current()->Send(new ViewHostMsg_AsyncOpenPepperFile( - routing_id_, infos[0].external_path, open_flags_, message_id)); + routing_id_, file_ref->GetSystemPath(), open_flags, message_id)); } + + state_manager_.SetPendingOperation(FileIOStateManager::OPERATION_EXCLUSIVE); + return PP_OK_COMPLETIONPENDING; } int32_t PepperFileIOHost::OnHostMsgTouch( diff --git a/content/renderer/pepper/pepper_file_io_host.h b/content/renderer/pepper/pepper_file_io_host.h index a49630d..0e26174 100644 --- a/content/renderer/pepper/pepper_file_io_host.h +++ b/content/renderer/pepper/pepper_file_io_host.h @@ -19,7 +19,6 @@ #include "ppapi/host/host_message_context.h" #include "ppapi/host/resource_host.h" #include "ppapi/shared_impl/file_io_state_manager.h" -#include "ppapi/shared_impl/file_ref_detailed_info.h" #include "ppapi/thunk/ppb_file_ref_api.h" #include "url/gurl.h" #include "webkit/common/quota/quota_types.h" @@ -27,7 +26,6 @@ using ppapi::host::ReplyMessageContext; namespace content { -class PepperPluginInstanceImpl; class QuotaFileIO; class PepperFileIOHost : public ppapi::host::ResourceHost, @@ -81,11 +79,6 @@ class PepperFileIOHost : public ppapi::host::ResourceHost, int32_t OnHostMsgWillSetLength(ppapi::host::HostMessageContext* context, int64_t length); - void DidGetFileRefInfo( - ppapi::host::ReplyMessageContext reply_context, - int flags, - const std::vector<ppapi::FileRefDetailedInfo>& infos); - // Callback handlers. These mostly convert the PlatformFileError to the // PP_Error code and send back the reply. Note that the argument // ReplyMessageContext is copied so that we have a closure containing all @@ -112,7 +105,7 @@ class PepperFileIOHost : public ppapi::host::ResourceHost, int bytes_written); RendererPpapiHost* renderer_ppapi_host_; - PepperPluginInstanceImpl* plugin_instance_; + base::PlatformFile file_; // The file system type specified in the Open() call. This will be diff --git a/content/renderer/pepper/pepper_in_process_resource_creation.cc b/content/renderer/pepper/pepper_in_process_resource_creation.cc index cb10ff2..9743bca5 100644 --- a/content/renderer/pepper/pepper_in_process_resource_creation.cc +++ b/content/renderer/pepper/pepper_in_process_resource_creation.cc @@ -19,7 +19,6 @@ #include "ppapi/proxy/ext_crx_file_system_private_resource.h" #include "ppapi/proxy/file_chooser_resource.h" #include "ppapi/proxy/file_io_resource.h" -#include "ppapi/proxy/file_ref_resource.h" #include "ppapi/proxy/file_system_resource.h" #include "ppapi/proxy/graphics_2d_resource.h" #include "ppapi/proxy/ppapi_messages.h" @@ -86,15 +85,6 @@ PP_Resource PepperInProcessResourceCreation::CreateFileIO( instance))->GetReference(); } -PP_Resource PepperInProcessResourceCreation::CreateFileRef( - PP_Instance instance, - const ppapi::FileRefCreateInfo& create_info) { - return ppapi::proxy::FileRefResource::CreateFileRef( - host_impl_->in_process_router()->GetPluginConnection(instance), - instance, - create_info); -} - PP_Resource PepperInProcessResourceCreation::CreateFileSystem( PP_Instance instance, PP_FileSystemType type) { diff --git a/content/renderer/pepper/pepper_in_process_resource_creation.h b/content/renderer/pepper/pepper_in_process_resource_creation.h index 847aac1..985ae09 100644 --- a/content/renderer/pepper/pepper_in_process_resource_creation.h +++ b/content/renderer/pepper/pepper_in_process_resource_creation.h @@ -49,9 +49,6 @@ class PepperInProcessResourceCreation : public ResourceCreationImpl { PP_FileChooserMode_Dev mode, const PP_Var& accept_types) OVERRIDE; virtual PP_Resource CreateFileIO(PP_Instance instance) OVERRIDE; - virtual PP_Resource CreateFileRef( - PP_Instance instance, - const ppapi::FileRefCreateInfo& create_info) OVERRIDE; virtual PP_Resource CreateFileSystem(PP_Instance instance, PP_FileSystemType type) OVERRIDE; virtual PP_Resource CreateGraphics2D( diff --git a/content/renderer/pepper/pepper_plugin_instance_impl.cc b/content/renderer/pepper/pepper_plugin_instance_impl.cc index 5eba21c..d88a10c 100644 --- a/content/renderer/pepper/pepper_plugin_instance_impl.cc +++ b/content/renderer/pepper/pepper_plugin_instance_impl.cc @@ -36,6 +36,7 @@ #include "content/renderer/pepper/plugin_module.h" #include "content/renderer/pepper/plugin_object.h" #include "content/renderer/pepper/ppb_buffer_impl.h" +#include "content/renderer/pepper/ppb_file_ref_impl.h" #include "content/renderer/pepper/ppb_graphics_3d_impl.h" #include "content/renderer/pepper/ppb_image_data_impl.h" #include "content/renderer/pepper/ppp_pdf.h" @@ -767,7 +768,6 @@ bool PepperPluginInstanceImpl::HandleDocumentLoad( DCHECK(pending_host_id); DataFromWebURLResponse( - host_impl, pp_instance(), response, base::Bind(&PepperPluginInstanceImpl::DidDataFromWebURLResponse, @@ -2607,6 +2607,13 @@ base::FilePath PepperPluginInstanceImpl::GetModulePath() { return module_->path(); } +PP_Resource PepperPluginInstanceImpl::CreateExternalFileReference( + const base::FilePath& external_file_path) { + PPB_FileRef_Impl* ref = PPB_FileRef_Impl::CreateExternal( + pp_instance(), external_file_path, ""); + return ref->GetReference(); +} + PP_Resource PepperPluginInstanceImpl::CreateImage(gfx::ImageSkia* source_image, float scale) { ui::ScaleFactor scale_factor = ui::GetScaleFactorFromScale(scale); @@ -2743,12 +2750,8 @@ int32_t PepperPluginInstanceImpl::Navigate( ppapi::URLRequestInfoData completed_request = request; WebURLRequest web_request; - if (!CreateWebURLRequest(pp_instance_, - &completed_request, - frame, - &web_request)) { + if (!CreateWebURLRequest(&completed_request, frame, &web_request)) return PP_ERROR_FAILED; - } web_request.setFirstPartyForCookies(document.firstPartyForCookies()); web_request.setHasUserGesture(from_user_action); diff --git a/content/renderer/pepper/pepper_plugin_instance_impl.h b/content/renderer/pepper/pepper_plugin_instance_impl.h index 930c55a..964b23b 100644 --- a/content/renderer/pepper/pepper_plugin_instance_impl.h +++ b/content/renderer/pepper/pepper_plugin_instance_impl.h @@ -347,6 +347,8 @@ class CONTENT_EXPORT PepperPluginInstanceImpl virtual ppapi::VarTracker* GetVarTracker() OVERRIDE; virtual const GURL& GetPluginURL() OVERRIDE; virtual base::FilePath GetModulePath() OVERRIDE; + virtual PP_Resource CreateExternalFileReference( + const base::FilePath& external_file_path) OVERRIDE; virtual PP_Resource CreateImage(gfx::ImageSkia* source_image, float scale) OVERRIDE; virtual PP_ExternalPluginResult SwitchToOutOfProcessProxy( diff --git a/content/renderer/pepper/pepper_url_loader_host.cc b/content/renderer/pepper/pepper_url_loader_host.cc index 60bb467..8343f19 100644 --- a/content/renderer/pepper/pepper_url_loader_host.cc +++ b/content/renderer/pepper/pepper_url_loader_host.cc @@ -250,12 +250,8 @@ int32_t PepperURLLoaderHost::InternalOnHostMsgOpen( if (!frame) return PP_ERROR_FAILED; WebURLRequest web_request; - if (!CreateWebURLRequest(pp_instance(), - &filled_in_request_data, - frame, - &web_request)) { + if (!CreateWebURLRequest(&filled_in_request_data, frame, &web_request)) return PP_ERROR_FAILED; - } web_request.setRequestorProcessID(renderer_ppapi_host_->GetPluginPID()); WebURLLoaderOptions options; @@ -393,7 +389,6 @@ void PepperURLLoaderHost::SaveResponse(const WebURLResponse& response) { pending_response_ = true; DataFromWebURLResponse( - renderer_ppapi_host_, pp_instance(), response, base::Bind(&PepperURLLoaderHost::DidDataFromWebURLResponse, diff --git a/content/renderer/pepper/pepper_url_request_unittest.cc b/content/renderer/pepper/pepper_url_request_unittest.cc index 05ca764..080c884 100644 --- a/content/renderer/pepper/pepper_url_request_unittest.cc +++ b/content/renderer/pepper/pepper_url_request_unittest.cc @@ -77,7 +77,7 @@ class URLRequestInfoTest : public RenderViewTest { bool GetDownloadToFile() { WebURLRequest web_request; URLRequestInfoData data = info_->GetData(); - if (!CreateWebURLRequest(pp_instance_, &data, GetMainFrame(), &web_request)) + if (!CreateWebURLRequest(&data, GetMainFrame(), &web_request)) return false; return web_request.downloadToFile(); } @@ -85,7 +85,7 @@ class URLRequestInfoTest : public RenderViewTest { WebCString GetURL() { WebURLRequest web_request; URLRequestInfoData data = info_->GetData(); - if (!CreateWebURLRequest(pp_instance_, &data, GetMainFrame(), &web_request)) + if (!CreateWebURLRequest(&data, GetMainFrame(), &web_request)) return WebCString(); return web_request.url().spec(); } @@ -93,7 +93,7 @@ class URLRequestInfoTest : public RenderViewTest { WebString GetMethod() { WebURLRequest web_request; URLRequestInfoData data = info_->GetData(); - if (!CreateWebURLRequest(pp_instance_, &data, GetMainFrame(), &web_request)) + if (!CreateWebURLRequest(&data, GetMainFrame(), &web_request)) return WebString(); return web_request.httpMethod(); } @@ -101,7 +101,7 @@ class URLRequestInfoTest : public RenderViewTest { WebString GetHeaderValue(const char* field) { WebURLRequest web_request; URLRequestInfoData data = info_->GetData(); - if (!CreateWebURLRequest(pp_instance_, &data, GetMainFrame(), &web_request)) + if (!CreateWebURLRequest(&data, GetMainFrame(), &web_request)) return WebString(); return web_request.httpHeaderField(WebString::fromUTF8(field)); } diff --git a/content/renderer/pepper/ppb_file_ref_impl.cc b/content/renderer/pepper/ppb_file_ref_impl.cc new file mode 100644 index 0000000..f664d79 --- /dev/null +++ b/content/renderer/pepper/ppb_file_ref_impl.cc @@ -0,0 +1,555 @@ +// Copyright (c) 2012 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 "content/renderer/pepper/ppb_file_ref_impl.h" + +#include "base/files/file_util_proxy.h" +#include "base/platform_file.h" +#include "base/strings/string_util.h" +#include "base/strings/utf_string_conversions.h" +#include "content/child/fileapi/file_system_dispatcher.h" +#include "content/common/view_messages.h" +#include "content/renderer/pepper/common.h" +#include "content/renderer/pepper/pepper_file_system_host.h" +#include "content/renderer/pepper/plugin_module.h" +#include "content/renderer/pepper/renderer_ppapi_host_impl.h" +#include "content/renderer/render_thread_impl.h" +#include "net/base/escape.h" +#include "ppapi/c/pp_errors.h" +#include "ppapi/c/ppb_file_io.h" +#include "ppapi/host/ppapi_host.h" +#include "ppapi/shared_impl/file_type_conversion.h" +#include "ppapi/shared_impl/time_conversion.h" +#include "ppapi/shared_impl/var.h" +#include "ppapi/thunk/enter.h" +#include "ppapi/thunk/ppb_file_system_api.h" +#include "url/gurl.h" +#include "webkit/common/fileapi/directory_entry.h" +#include "webkit/common/fileapi/file_system_util.h" + +using ppapi::HostResource; +using ppapi::PPB_FileRef_CreateInfo; +using ppapi::PPTimeToTime; +using ppapi::StringVar; +using ppapi::TrackedCallback; +using ppapi::thunk::EnterResourceNoLock; +using ppapi::thunk::PPB_FileRef_API; +using ppapi::thunk::PPB_FileSystem_API; + +namespace content { + +namespace { + +bool IsValidLocalPath(const std::string& path) { + // The path must start with '/' + if (path.empty() || path[0] != '/') + return false; + + // The path must contain valid UTF-8 characters. + if (!IsStringUTF8(path)) + return false; + +#if defined(OS_WIN) + base::FilePath::StringType path_win(path.begin(), path.end()); + base::FilePath file_path(path_win); +#else + base::FilePath file_path(path); +#endif + if (file_path.ReferencesParent()) + return false; + + return true; +} + +void TrimTrailingSlash(std::string* path) { + // If this path ends with a slash, then normalize it away unless path is the + // root path. + if (path->size() > 1 && path->at(path->size() - 1) == '/') + path->erase(path->size() - 1, 1); +} + +std::string GetNameForExternalFilePath(const base::FilePath& in_path) { + const base::FilePath::StringType& path = in_path.value(); + size_t pos = path.rfind(base::FilePath::kSeparators[0]); + CHECK(pos != base::FilePath::StringType::npos); +#if defined(OS_WIN) + return WideToUTF8(path.substr(pos + 1)); +#elif defined(OS_POSIX) + return path.substr(pos + 1); +#else +#error "Unsupported platform." +#endif +} + +std::string GetNameForVirtualFilePath(const std::string& path) { + if (path.size() == 1 && path[0] == '/') + return path; + + // There should always be a leading slash at least! + size_t pos = path.rfind('/'); + CHECK(pos != std::string::npos); + return path.substr(pos + 1); +} + +void IgnoreCloseCallback(base::PlatformFileError error_code) { +} + +void PlatformFileInfoToPPFileInfo( + const base::PlatformFileInfo& file_info, + PP_FileSystemType file_system_type, + PP_FileInfo* info) { + DCHECK(info); + ppapi::PlatformFileInfoToPepperFileInfo(file_info, file_system_type, info); +} + +void GetFileInfoCallback( + scoped_refptr<base::TaskRunner> task_runner, + base::PlatformFile file, + linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback, + base::PlatformFileError error_code, + const base::PlatformFileInfo& file_info) { + base::FileUtilProxy::Close( + task_runner.get(), file, base::Bind(&IgnoreCloseCallback)); + + if (!TrackedCallback::IsPending(callback)) + return; + + int32_t pp_error = ppapi::PlatformFileErrorToPepperError(error_code); + if (pp_error != PP_OK) { + callback->Run(pp_error); + return; + } + + PlatformFileInfoToPPFileInfo( + file_info, PP_FILESYSTEMTYPE_EXTERNAL, info.get()); + + callback->Run(PP_OK); +} + +void QueryCallback(scoped_refptr<base::TaskRunner> task_runner, + linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback, + base::PlatformFileError error_code, + base::PassPlatformFile passed_file) { + if (!TrackedCallback::IsPending(callback)) + return; + + int32_t pp_error = ppapi::PlatformFileErrorToPepperError(error_code); + if (pp_error != PP_OK) { + callback->Run(pp_error); + return; + } + base::PlatformFile file = passed_file.ReleaseValue(); + + if (!base::FileUtilProxy::GetFileInfoFromPlatformFile( + task_runner.get(), + file, + base::Bind( + &GetFileInfoCallback, task_runner, file, info, callback))) { + base::FileUtilProxy::Close( + task_runner.get(), file, base::Bind(&IgnoreCloseCallback)); + callback->Run(PP_ERROR_FAILED); + } +} + +void DidReadMetadata( + scoped_refptr<ppapi::TrackedCallback> callback, + linked_ptr<PP_FileInfo> info, + PP_FileSystemType file_system_type, + const base::PlatformFileInfo& file_info) { + if (!TrackedCallback::IsPending(callback)) + return; + + PlatformFileInfoToPPFileInfo(file_info, file_system_type, info.get()); + callback->Run(PP_OK); +} + +void DidReadDirectory( + scoped_refptr<ppapi::TrackedCallback> callback, + PPB_FileRef_Impl* dir_ref, + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > dir_files, + linked_ptr<std::vector<PP_FileType> > dir_file_types, + const std::vector<fileapi::DirectoryEntry>& entries, + bool has_more) { + if (!TrackedCallback::IsPending(callback)) + return; + + // The current filesystem backend always returns false. + DCHECK(!has_more); + + DCHECK(dir_ref); + DCHECK(dir_files.get()); + DCHECK(dir_file_types.get()); + + std::string dir_path = dir_ref->GetCreateInfo().path; + if (dir_path.empty() || dir_path[dir_path.size() - 1] != '/') + dir_path += '/'; + + for (size_t i = 0; i < entries.size(); ++i) { + const fileapi::DirectoryEntry& entry = entries[i]; + scoped_refptr<PPB_FileRef_Impl> file_ref(PPB_FileRef_Impl::CreateInternal( + dir_ref->pp_instance(), + dir_ref->file_system_resource(), + dir_path + fileapi::FilePathToString(base::FilePath(entry.name)))); + dir_files->push_back(file_ref->GetCreateInfo()); + dir_file_types->push_back( + entry.is_directory ? PP_FILETYPE_DIRECTORY : PP_FILETYPE_REGULAR); + // Add a ref count on behalf of the plugin side. + file_ref->GetReference(); + } + CHECK_EQ(dir_files->size(), dir_file_types->size()); + + callback->Run(PP_OK); +} + +void DidFinishFileOperation( + scoped_refptr<ppapi::TrackedCallback> callback, + base::PlatformFileError error_code) { + if (callback->completed()) + return; + callback->Run(ppapi::PlatformFileErrorToPepperError(error_code)); +} + +} // namespace + +PPB_FileRef_Impl::PPB_FileRef_Impl(const PPB_FileRef_CreateInfo& info, + PP_Resource file_system) + : PPB_FileRef_Shared(ppapi::OBJECT_IS_IMPL, info), + file_system_(file_system), + external_file_system_path_(), + routing_id_(MSG_ROUTING_NONE) { + if (RenderThreadImpl::current()) { // NULL in tests. + routing_id_ = RenderThreadImpl::current()->GenerateRoutingID(); + ChildThread::current()->AddRoute(routing_id_, this); + } +} + +PPB_FileRef_Impl::PPB_FileRef_Impl(const PPB_FileRef_CreateInfo& info, + const base::FilePath& external_file_path) + : PPB_FileRef_Shared(ppapi::OBJECT_IS_IMPL, info), + file_system_(), + external_file_system_path_(external_file_path), + routing_id_(MSG_ROUTING_NONE) { + if (RenderThreadImpl::current()) { // NULL in tests. + routing_id_ = RenderThreadImpl::current()->GenerateRoutingID(); + ChildThread::current()->AddRoute(routing_id_, this); + } +} + +PPB_FileRef_Impl::~PPB_FileRef_Impl() { + if (RenderThreadImpl::current()) + ChildThread::current()->RemoveRoute(routing_id_); +} + +// static +PPB_FileRef_Impl* PPB_FileRef_Impl::CreateInternal(PP_Instance instance, + PP_Resource pp_file_system, + const std::string& path) { + PepperFileSystemHost* fs_host = GetFileSystemHostInternal( + instance, pp_file_system); + if (!fs_host) + return 0; + + PP_FileSystemType type = fs_host->GetType(); + if (type != PP_FILESYSTEMTYPE_LOCALPERSISTENT && + type != PP_FILESYSTEMTYPE_LOCALTEMPORARY && + type != PP_FILESYSTEMTYPE_EXTERNAL && + type != PP_FILESYSTEMTYPE_ISOLATED) + return 0; + + PPB_FileRef_CreateInfo info; + info.resource = HostResource::MakeInstanceOnly(instance); + info.file_system_plugin_resource = pp_file_system; + info.file_system_type = type; + + // Validate the path. + info.path = path; + if (!IsValidLocalPath(info.path)) + return 0; + TrimTrailingSlash(&info.path); + + info.name = GetNameForVirtualFilePath(info.path); + + PPB_FileRef_Impl* file_ref = new PPB_FileRef_Impl(info, pp_file_system); + + RendererPpapiHostImpl* renderer_host = + RendererPpapiHostImpl::GetForPPInstance(instance); + if (renderer_host && renderer_host->IsRunningInProcess()) + file_ref->AddFileSystemRefCount(); + return file_ref; +} + +// static +PPB_FileRef_Impl* PPB_FileRef_Impl::CreateExternal( + PP_Instance instance, + const base::FilePath& external_file_path, + const std::string& display_name) { + PPB_FileRef_CreateInfo info; + info.resource = HostResource::MakeInstanceOnly(instance); + info.file_system_plugin_resource = 0; + info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL; + if (display_name.empty()) + info.name = GetNameForExternalFilePath(external_file_path); + else + info.name = display_name; + + return new PPB_FileRef_Impl(info, external_file_path); +} + +PP_Resource PPB_FileRef_Impl::GetParent() { + if (GetFileSystemType() == PP_FILESYSTEMTYPE_EXTERNAL) + return 0; + + const std::string& virtual_path = GetCreateInfo().path; + + // There should always be a leading slash at least! + size_t pos = virtual_path.rfind('/'); + CHECK(pos != std::string::npos); + + // If the path is "/foo", then we want to include the slash. + if (pos == 0) + pos++; + std::string parent_path = virtual_path.substr(0, pos); + + scoped_refptr<PPB_FileRef_Impl> parent_ref( + CreateInternal(pp_instance(), file_system_, parent_path)); + if (!parent_ref.get()) + return 0; + return parent_ref->GetReference(); +} + +int32_t PPB_FileRef_Impl::MakeDirectory( + PP_Bool make_ancestors, + scoped_refptr<TrackedCallback> callback) { + if (!IsValidNonExternalFileSystem()) + return PP_ERROR_NOACCESS; + + FileSystemDispatcher* file_system_dispatcher = + ChildThread::current()->file_system_dispatcher(); + file_system_dispatcher->CreateDirectory( + GetFileSystemURL(), false /* exclusive */, PP_ToBool(make_ancestors), + base::Bind(&DidFinishFileOperation, callback)); + return PP_OK_COMPLETIONPENDING; +} + +int32_t PPB_FileRef_Impl::Touch(PP_Time last_access_time, + PP_Time last_modified_time, + scoped_refptr<TrackedCallback> callback) { + if (!IsValidNonExternalFileSystem()) + return PP_ERROR_NOACCESS; + + FileSystemDispatcher* file_system_dispatcher = + ChildThread::current()->file_system_dispatcher(); + file_system_dispatcher->TouchFile( + GetFileSystemURL(), + PPTimeToTime(last_access_time), + PPTimeToTime(last_modified_time), + base::Bind(&DidFinishFileOperation, callback)); + return PP_OK_COMPLETIONPENDING; +} + +int32_t PPB_FileRef_Impl::Delete(scoped_refptr<TrackedCallback> callback) { + if (!IsValidNonExternalFileSystem()) + return PP_ERROR_NOACCESS; + + FileSystemDispatcher* file_system_dispatcher = + ChildThread::current()->file_system_dispatcher(); + file_system_dispatcher->Remove( + GetFileSystemURL(), + false /* recursive */, + base::Bind(&DidFinishFileOperation, callback)); + return PP_OK_COMPLETIONPENDING; +} + +int32_t PPB_FileRef_Impl::Rename(PP_Resource new_pp_file_ref, + scoped_refptr<TrackedCallback> callback) { + EnterResourceNoLock<PPB_FileRef_API> enter(new_pp_file_ref, true); + if (enter.failed()) + return PP_ERROR_BADRESOURCE; + PPB_FileRef_Impl* new_file_ref = + static_cast<PPB_FileRef_Impl*>(enter.object()); + + if (!IsValidNonExternalFileSystem() || + file_system_ != new_file_ref->file_system_) + return PP_ERROR_NOACCESS; + + // TODO(viettrungluu): Also cancel when the new file ref is destroyed? + // http://crbug.com/67624 + FileSystemDispatcher* file_system_dispatcher = + ChildThread::current()->file_system_dispatcher(); + file_system_dispatcher->Move( + GetFileSystemURL(), new_file_ref->GetFileSystemURL(), + base::Bind(&DidFinishFileOperation, callback)); + return PP_OK_COMPLETIONPENDING; +} + +PP_Var PPB_FileRef_Impl::GetAbsolutePath() { + if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL) + return GetPath(); + if (!external_path_var_.get()) { + external_path_var_ = + new StringVar(external_file_system_path_.AsUTF8Unsafe()); + } + return external_path_var_->GetPPVar(); +} + +base::FilePath PPB_FileRef_Impl::GetSystemPath() const { + if (GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL) { + NOTREACHED(); + return base::FilePath(); + } + return external_file_system_path_; +} + +GURL PPB_FileRef_Impl::GetFileSystemURL() const { + if (GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALPERSISTENT && + GetFileSystemType() != PP_FILESYSTEMTYPE_LOCALTEMPORARY && + GetFileSystemType() != PP_FILESYSTEMTYPE_EXTERNAL && + GetFileSystemType() != PP_FILESYSTEMTYPE_ISOLATED) { + NOTREACHED(); + return GURL(); + } + + const std::string& virtual_path = GetCreateInfo().path; + CHECK(!virtual_path.empty()); // Should always be at least "/". + + // Since |virtual_path_| starts with a '/', it looks like an absolute path. + // We need to trim off the '/' before calling Resolve, as FileSystem URLs + // start with a storage type identifier that looks like a path segment. + + PepperFileSystemHost* host = GetFileSystemHost(); + if (!host) + return GURL(); + + return GURL(host->GetRootUrl()).Resolve(net::EscapePath( + virtual_path.substr(1))); +} + +bool PPB_FileRef_Impl::OnMessageReceived(const IPC::Message& msg) { + bool handled = true; + IPC_BEGIN_MESSAGE_MAP(PPB_FileRef_Impl, msg) + IPC_MESSAGE_HANDLER(ViewMsg_AsyncOpenPepperFile_ACK, OnAsyncFileOpened) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP() + return handled; +} + +void PPB_FileRef_Impl::OnAsyncFileOpened( + base::PlatformFileError error_code, + IPC::PlatformFileForTransit file_for_transit, + int message_id) { + AsyncOpenFileCallback* callback = + pending_async_open_files_.Lookup(message_id); + DCHECK(callback); + pending_async_open_files_.Remove(message_id); + + base::PlatformFile file = + IPC::PlatformFileForTransitToPlatformFile(file_for_transit); + callback->Run(error_code, base::PassPlatformFile(&file)); + // Make sure we won't leak file handle if the requester has died. + if (file != base::kInvalidPlatformFileValue) { + base::FileUtilProxy::Close( + RenderThreadImpl::current()->GetFileThreadMessageLoopProxy().get(), + file, + base::FileUtilProxy::StatusCallback()); + } + delete callback; +} + +bool PPB_FileRef_Impl::IsValidNonExternalFileSystem() const { + PepperFileSystemHost* host = GetFileSystemHost(); + return HasValidFileSystem() && host && + host->GetType() != PP_FILESYSTEMTYPE_EXTERNAL; +} + +bool PPB_FileRef_Impl::HasValidFileSystem() const { + PepperFileSystemHost* host = GetFileSystemHost(); + return host && host->IsOpened(); +} + +int32_t PPB_FileRef_Impl::Query(PP_FileInfo* info, + scoped_refptr<TrackedCallback> callback) { + NOTREACHED(); + return PP_ERROR_FAILED; +} + +int32_t PPB_FileRef_Impl::QueryInHost( + linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback) { + if (!file_system_) { + // External file system + // We have to do something totally different for external file systems. + + // TODO(teravest): Use the SequencedWorkerPool instead. + scoped_refptr<base::TaskRunner> task_runner = + RenderThreadImpl::current()->GetFileThreadMessageLoopProxy(); + + int message_id = pending_async_open_files_.Add(new AsyncOpenFileCallback( + base::Bind(&QueryCallback, task_runner, info, callback))); + RenderThreadImpl::current()->Send(new ViewHostMsg_AsyncOpenPepperFile( + routing_id_, + GetSystemPath(), + PP_FILEOPENFLAG_READ, + message_id)); + } else { + // Non-external file system + if (!HasValidFileSystem()) + return PP_ERROR_NOACCESS; + + PP_FileSystemType file_system_type = GetFileSystemHost()->GetType(); + FileSystemDispatcher* file_system_dispatcher = + ChildThread::current()->file_system_dispatcher(); + file_system_dispatcher->ReadMetadata( + GetFileSystemURL(), + base::Bind(&DidReadMetadata, callback, info, file_system_type), + base::Bind(&DidFinishFileOperation, callback)); + } + return PP_OK_COMPLETIONPENDING; +} + +int32_t PPB_FileRef_Impl::ReadDirectoryEntries( + const PP_ArrayOutput& output, + scoped_refptr<TrackedCallback> callback) { + NOTREACHED(); + return PP_ERROR_FAILED; +} + +int32_t PPB_FileRef_Impl::ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<TrackedCallback> callback) { + if (!IsValidNonExternalFileSystem()) + return PP_ERROR_NOACCESS; + + // TODO(yzshen): Passing base::Unretained(this) to the callback could + // be dangerous. + FileSystemDispatcher* file_system_dispatcher = + ChildThread::current()->file_system_dispatcher(); + file_system_dispatcher->ReadDirectory( + GetFileSystemURL(), + base::Bind(&DidReadDirectory, + callback, base::Unretained(this), files, file_types), + base::Bind(&DidFinishFileOperation, callback)); + return PP_OK_COMPLETIONPENDING; +} + +PepperFileSystemHost* PPB_FileRef_Impl::GetFileSystemHost() const { + return GetFileSystemHostInternal(pp_instance(), file_system_); +} + +PepperFileSystemHost* PPB_FileRef_Impl::GetFileSystemHostInternal( + PP_Instance instance, PP_Resource resource) { + const ppapi::host::PpapiHost* ppapi_host = + RendererPpapiHost::GetForPPInstance(instance)->GetPpapiHost(); + if (!resource || !ppapi_host) + return NULL; + ppapi::host::ResourceHost* resource_host = + ppapi_host->GetResourceHost(resource); + if (resource_host && resource_host->IsFileSystemHost()) + return static_cast<PepperFileSystemHost*>(resource_host); + return NULL; +} + +} // namespace content diff --git a/content/renderer/pepper/ppb_file_ref_impl.h b/content/renderer/pepper/ppb_file_ref_impl.h new file mode 100644 index 0000000..9c31885 --- /dev/null +++ b/content/renderer/pepper/ppb_file_ref_impl.h @@ -0,0 +1,155 @@ +// Copyright (c) 2012 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. + +#ifndef CONTENT_RENDERER_PEPPER_PPB_FILE_REF_IMPL_H_ +#define CONTENT_RENDERER_PEPPER_PPB_FILE_REF_IMPL_H_ + +#include <string> +#include <vector> + +#include "base/callback_forward.h" +#include "base/files/file_path.h" +#include "base/id_map.h" +#include "base/memory/linked_ptr.h" +#include "base/platform_file.h" +#include "ipc/ipc_listener.h" +#include "ipc/ipc_platform_file.h" +#include "ppapi/c/pp_file_info.h" +#include "ppapi/c/ppb_file_ref.h" +#include "ppapi/shared_impl/ppb_file_ref_shared.h" +#include "ppapi/shared_impl/scoped_pp_resource.h" +#include "ppapi/shared_impl/var.h" +#include "url/gurl.h" + +namespace ppapi { +namespace host { +class ResourceHost; +} +} + +namespace content { + +using ppapi::StringVar; + +class PepperFileSystemHost; + +class PPB_FileRef_Impl : public ppapi::PPB_FileRef_Shared, + public IPC::Listener { + public: + PPB_FileRef_Impl(const ppapi::PPB_FileRef_CreateInfo& info, + PP_Resource file_system); + PPB_FileRef_Impl(const ppapi::PPB_FileRef_CreateInfo& info, + const base::FilePath& external_file_path); + + // The returned object will have a refcount of 0 (just like "new"). + static PPB_FileRef_Impl* CreateInternal(PP_Instance instance, + PP_Resource pp_file_system, + const std::string& path); + + // The returned object will have a refcount of 0 (just like "new"). + static PPB_FileRef_Impl* CreateExternal( + PP_Instance instance, + const base::FilePath& external_file_path, + const std::string& display_name); + + // PPB_FileRef_API implementation (not provided by PPB_FileRef_Shared). + virtual PP_Resource GetParent() OVERRIDE; + virtual int32_t MakeDirectory( + PP_Bool make_ancestors, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t Touch( + PP_Time last_access_time, + PP_Time last_modified_time, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t Delete( + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t Rename( + PP_Resource new_file_ref, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t Query( + PP_FileInfo* info, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t ReadDirectoryEntries( + const PP_ArrayOutput& output, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t QueryInHost( + linked_ptr<PP_FileInfo> info, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual int32_t ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<ppapi::TrackedCallback> callback) OVERRIDE; + virtual PP_Var GetAbsolutePath() OVERRIDE; + + PP_Resource file_system_resource() const { return file_system_; } + + // Returns the system path corresponding to this file. Valid only for + // external filesystems. + base::FilePath GetSystemPath() const; + + // Returns the FileSystem API URL corresponding to this file. + GURL GetFileSystemURL() const; + + // Checks if file ref has file system instance and if the instance is opened. + bool HasValidFileSystem() const; + + void AddFileSystemRefCount() { + file_system_ref_ = file_system_; + } + + private: + virtual ~PPB_FileRef_Impl(); + + // IPC::Listener implementation. + virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; + + void OnAsyncFileOpened( + base::PlatformFileError error_code, + IPC::PlatformFileForTransit file_for_transit, + int message_id); + + // Many mutation functions are allow only to non-external filesystems, This + // function returns true if the filesystem is opened and isn't external as an + // access check for these functions. + bool IsValidNonExternalFileSystem() const; + + PepperFileSystemHost* GetFileSystemHost() const; + static PepperFileSystemHost* GetFileSystemHostInternal( + PP_Instance instance, PP_Resource resource); + + // 0 for external filesystems. This is a plugin side resource that we don't + // hold a reference here, so file_system_ could be destroyed earlier than + // this object. Right now we checked the existance in plugin delegate before + // use. But it's better to hold a reference once we migrate FileRef to the + // new design. + PP_Resource file_system_; + + // Holds a reference of FileSystem when running in process. See + // PPB_FileRef_Proxy for corresponding code for out-of-process mode. Note + // that this ScopedPPResource is only expected to be used when running in + // process (since PPB_FileRef_Proxy takes care of out-of-process case). + // Also note that this workaround will be no longer needed after FileRef + // refactoring. + ppapi::ScopedPPResource file_system_ref_; + + // Used only for external filesystems. + base::FilePath external_file_system_path_; + + // Lazily initialized var created from the external path. This is so we can + // return the identical string object every time it is requested. + scoped_refptr<StringVar> external_path_var_; + + int routing_id_; + + typedef base::Callback<void (base::PlatformFileError, base::PassPlatformFile)> + AsyncOpenFileCallback; + + IDMap<AsyncOpenFileCallback> pending_async_open_files_; + + DISALLOW_COPY_AND_ASSIGN(PPB_FileRef_Impl); +}; + +} // namespace content + +#endif // CONTENT_RENDERER_PEPPER_PPB_FILE_REF_IMPL_H_ diff --git a/content/renderer/pepper/resource_creation_impl.cc b/content/renderer/pepper/resource_creation_impl.cc index cddc891..8cc43091 100644 --- a/content/renderer/pepper/resource_creation_impl.cc +++ b/content/renderer/pepper/resource_creation_impl.cc @@ -8,6 +8,7 @@ #include "content/renderer/pepper/ppb_audio_impl.h" #include "content/renderer/pepper/ppb_broker_impl.h" #include "content/renderer/pepper/ppb_buffer_impl.h" +#include "content/renderer/pepper/ppb_file_ref_impl.h" #include "content/renderer/pepper/ppb_flash_message_loop_impl.h" #include "content/renderer/pepper/ppb_graphics_3d_impl.h" #include "content/renderer/pepper/ppb_image_data_impl.h" @@ -71,6 +72,22 @@ PP_Resource ResourceCreationImpl::CreateBuffer(PP_Instance instance, return PPB_Buffer_Impl::Create(instance, size); } +PP_Resource ResourceCreationImpl::CreateFileRef( + PP_Instance instance, + PP_Resource file_system, + const char* path) { + PPB_FileRef_Impl* res = PPB_FileRef_Impl::CreateInternal( + instance, file_system, path); + return res ? res->GetReference() : 0; +} + +PP_Resource ResourceCreationImpl::CreateFileRef( + const ppapi::PPB_FileRef_CreateInfo& serialized) { + // When we're in-process, the host resource in the create info *is* the + // resource, so we don't need to do anything. + return serialized.resource.host_resource(); +} + PP_Resource ResourceCreationImpl::CreateFlashDRM(PP_Instance instance) { return 0; // Not supported in-process. } diff --git a/content/renderer/pepper/resource_creation_impl.h b/content/renderer/pepper/resource_creation_impl.h index 30ddf63..dc05890 100644 --- a/content/renderer/pepper/resource_creation_impl.h +++ b/content/renderer/pepper/resource_creation_impl.h @@ -35,6 +35,11 @@ class ResourceCreationImpl : public ppapi::thunk::ResourceCreationAPI { virtual PP_Resource CreateBroker(PP_Instance instance) OVERRIDE; virtual PP_Resource CreateBuffer(PP_Instance instance, uint32_t size) OVERRIDE; + virtual PP_Resource CreateFileRef(PP_Instance instance, + PP_Resource file_system, + const char* path) OVERRIDE; + virtual PP_Resource CreateFileRef( + const ppapi::PPB_FileRef_CreateInfo& serialized) OVERRIDE; virtual PP_Resource CreateFlashDRM(PP_Instance instance) OVERRIDE; virtual PP_Resource CreateFlashFontFile( PP_Instance instance, diff --git a/content/renderer/pepper/url_request_info_util.cc b/content/renderer/pepper/url_request_info_util.cc index 5b3786b..e82c8a1 100644 --- a/content/renderer/pepper/url_request_info_util.cc +++ b/content/renderer/pepper/url_request_info_util.cc @@ -8,13 +8,10 @@ #include "base/strings/string_util.h" #include "content/common/fileapi/file_system_messages.h" #include "content/renderer/pepper/common.h" -#include "content/renderer/pepper/host_globals.h" -#include "content/renderer/pepper/pepper_plugin_instance_impl.h" #include "content/renderer/pepper/plugin_module.h" +#include "content/renderer/pepper/ppb_file_ref_impl.h" #include "content/renderer/render_thread_impl.h" #include "net/http/http_util.h" -#include "ppapi/proxy/ppapi_messages.h" -#include "ppapi/shared_impl/file_ref_detailed_info.h" #include "ppapi/shared_impl/url_request_info_data.h" #include "ppapi/shared_impl/var.h" #include "ppapi/thunk/enter.h" @@ -28,9 +25,10 @@ #include "url/url_util.h" #include "webkit/child/weburlrequest_extradata_impl.h" -using ppapi::Resource; using ppapi::URLRequestInfoData; +using ppapi::Resource; using ppapi::thunk::EnterResourceNoLock; +using ppapi::thunk::PPB_FileRef_API; using WebKit::WebData; using WebKit::WebHTTPBody; using WebKit::WebString; @@ -45,23 +43,32 @@ namespace { // Appends the file ref given the Resource pointer associated with it to the // given HTTP body, returning true on success. bool AppendFileRefToBody( - const ppapi::FileRefDetailedInfo& file_info, + Resource* file_ref_resource, int64_t start_offset, int64_t number_of_bytes, PP_Time expected_last_modified_time, WebHTTPBody *http_body) { + // Get the underlying file ref impl. + if (!file_ref_resource) + return false; + PPB_FileRef_API* file_ref_api = file_ref_resource->AsPPB_FileRef_API(); + if (!file_ref_api) + return false; + const PPB_FileRef_Impl* file_ref = + static_cast<PPB_FileRef_Impl*>(file_ref_api); + base::FilePath platform_path; - switch (file_info.file_system_type) { + switch (file_ref->GetFileSystemType()) { case PP_FILESYSTEMTYPE_LOCALTEMPORARY: case PP_FILESYSTEMTYPE_LOCALPERSISTENT: // TODO(kinuko): remove this sync IPC when we fully support // AppendURLRange for FileSystem URL. RenderThreadImpl::current()->Send( new FileSystemHostMsg_SyncGetPlatformPath( - GURL(file_info.file_system_url_spec), &platform_path)); + file_ref->GetFileSystemURL(), &platform_path)); break; case PP_FILESYSTEMTYPE_EXTERNAL: - platform_path = file_info.external_path; + platform_path = file_ref->GetSystemPath(); break; default: NOTREACHED(); @@ -77,7 +84,7 @@ bool AppendFileRefToBody( // Checks that the request data is valid. Returns false on failure. Note that // method and header validation is done by the URL loader when the request is // opened, and any access errors are returned asynchronously. -bool ValidateURLRequestData(const URLRequestInfoData& data) { +bool ValidateURLRequestData(const ppapi::URLRequestInfoData& data) { if (data.prefetch_buffer_lower_threshold < 0 || data.prefetch_buffer_upper_threshold < 0 || data.prefetch_buffer_upper_threshold <= @@ -87,16 +94,33 @@ bool ValidateURLRequestData(const URLRequestInfoData& data) { return true; } +// Ensures that the file_ref members of the given request info data are +// populated from the resource IDs. Returns true on success. +bool EnsureFileRefObjectsPopulated(ppapi::URLRequestInfoData* data) { + // Get the Resource objects for any file refs with only host resource (this + // is the state of the request as it comes off IPC). + for (size_t i = 0; i < data->body.size(); ++i) { + URLRequestInfoData::BodyItem& item = data->body[i]; + if (item.is_file && !item.file_ref.get()) { + EnterResourceNoLock<PPB_FileRef_API> enter( + item.file_ref_host_resource.host_resource(), false); + if (!enter.succeeded()) + return false; + item.file_ref = enter.resource(); + } + } + return true; +} + } // namespace -bool CreateWebURLRequest(PP_Instance instance, - URLRequestInfoData* data, +bool CreateWebURLRequest(ppapi::URLRequestInfoData* data, WebFrame* frame, WebURLRequest* dest) { // In the out-of-process case, we've received the URLRequestInfoData // from the untrusted plugin and done no validation on it. We need to be // sure it's not being malicious by checking everything for consistency. - if (!ValidateURLRequestData(*data)) + if (!ValidateURLRequestData(*data) || !EnsureFileRefObjectsPopulated(data)) return false; dest->initialize(); @@ -121,44 +145,19 @@ bool CreateWebURLRequest(PP_Instance instance, } } - // Get file information for FileRefs inside BodyItems. - std::vector<PP_Resource> resources; - for (size_t i = 0; i < data->body.size(); ++i) { - const URLRequestInfoData::BodyItem& item = data->body[i]; - if (item.is_file) - resources.push_back(item.file_ref_pp_resource); - } - std::vector<ppapi::FileRefDetailedInfo> infos; - - if (!resources.empty()) { - PepperPluginInstanceImpl* instance_impl = - HostGlobals::Get()->GetInstance(instance); - int child_process_id = instance_impl->module()->GetPluginChildId(); - // The routing id is automatically populated for us when set to 0. - RenderThreadImpl::current()->Send( - new PpapiHostMsg_FileRef_SyncGetInfoForRenderer( - 0, child_process_id, resources, &infos)); - if (infos.size() != resources.size()) - return false; - } - // Append the upload data. if (!data->body.empty()) { WebHTTPBody http_body; http_body.initialize(); - int file_index = 0; for (size_t i = 0; i < data->body.size(); ++i) { const URLRequestInfoData::BodyItem& item = data->body[i]; if (item.is_file) { - if (item.file_ref_pp_resource != infos[file_index].resource) - return false; - if (!AppendFileRefToBody(infos[file_index], + if (!AppendFileRefToBody(item.file_ref.get(), item.start_offset, item.number_of_bytes, item.expected_last_modified_time, &http_body)) return false; - file_index++; } else { DCHECK(!item.data.empty()); http_body.appendData(WebData(item.data)); @@ -191,7 +190,7 @@ bool CreateWebURLRequest(PP_Instance instance, return true; } -bool URLRequestRequiresUniversalAccess(const URLRequestInfoData& data) { +bool URLRequestRequiresUniversalAccess(const ppapi::URLRequestInfoData& data) { return data.has_custom_referrer_url || data.has_custom_content_transfer_encoding || diff --git a/content/renderer/pepper/url_request_info_util.h b/content/renderer/pepper/url_request_info_util.h index 2fb40e6..2a93fe6 100644 --- a/content/renderer/pepper/url_request_info_util.h +++ b/content/renderer/pepper/url_request_info_util.h @@ -7,7 +7,6 @@ #include "base/memory/ref_counted.h" #include "content/common/content_export.h" -#include "ppapi/c/pp_instance.h" namespace ppapi { struct URLRequestInfoData; @@ -24,8 +23,7 @@ namespace content { // on success, false if the request is invalid (in which case *dest may be // partially initialized). Any upload files with only resource IDs (no file ref // pointers) will be populated by this function on success. -CONTENT_EXPORT bool CreateWebURLRequest(PP_Instance instance, - ppapi::URLRequestInfoData* data, +CONTENT_EXPORT bool CreateWebURLRequest(ppapi::URLRequestInfoData* data, WebKit::WebFrame* frame, WebKit::WebURLRequest* dest); diff --git a/content/renderer/pepper/url_response_info_util.cc b/content/renderer/pepper/url_response_info_util.cc index 811ed35..a9eccef 100644 --- a/content/renderer/pepper/url_response_info_util.cc +++ b/content/renderer/pepper/url_response_info_util.cc @@ -7,10 +7,7 @@ #include "base/bind.h" #include "base/files/file_path.h" #include "base/message_loop/message_loop.h" -#include "content/public/renderer/renderer_ppapi_host.h" -#include "content/renderer/pepper/renderer_ppapi_host_impl.h" -#include "ipc/ipc_message.h" -#include "ppapi/proxy/ppapi_messages.h" +#include "content/renderer/pepper/ppb_file_ref_impl.h" #include "ppapi/shared_impl/url_response_info_data.h" #include "third_party/WebKit/public/platform/WebCString.h" #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h" @@ -46,23 +43,13 @@ bool IsRedirect(int32_t status) { return status >= 300 && status <= 399; } -void DidCreateResourceHost(const ppapi::URLResponseInfoData& in_data, - const base::FilePath& external_path, - const DataFromWebURLResponseCallback& callback, - int pending_resource_id) { - ppapi::URLResponseInfoData data = in_data; - data.body_as_file_ref = ppapi::MakeExternalFileRefCreateInfo( - external_path, std::string(), pending_resource_id); - callback.Run(data); -} - } // namespace -void DataFromWebURLResponse(RendererPpapiHostImpl* host_impl, - PP_Instance pp_instance, +void DataFromWebURLResponse(PP_Instance pp_instance, const WebURLResponse& response, const DataFromWebURLResponseCallback& callback) { ppapi::URLResponseInfoData data; + data.url = response.url().spec(); data.status_code = response.httpStatusCode(); data.status_text = response.httpStatusText().utf8(); @@ -77,16 +64,18 @@ void DataFromWebURLResponse(RendererPpapiHostImpl* host_impl, WebString file_path = response.downloadFilePath(); if (!file_path.isEmpty()) { - base::FilePath external_path = base::FilePath::FromUTF16Unsafe(file_path); - host_impl->CreateBrowserResourceHost( - pp_instance, - PpapiHostMsg_FileRef_CreateExternal(external_path), - base::Bind(&DidCreateResourceHost, data, external_path, callback)); - } else { - base::MessageLoop::current()->PostTask( - FROM_HERE, - base::Bind(callback, data)); + scoped_refptr<PPB_FileRef_Impl> file_ref( + PPB_FileRef_Impl::CreateExternal( + pp_instance, + base::FilePath::FromUTF16Unsafe(file_path), + std::string())); + data.body_as_file_ref = file_ref->GetCreateInfo(); + file_ref->GetReference(); // The returned data has one ref for the plugin. } + + // We post data to a callback instead of returning it here because the new + // implementation for FileRef is asynchronous when creating the resource. + base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, data)); } } // namespace content diff --git a/content/renderer/pepper/url_response_info_util.h b/content/renderer/pepper/url_response_info_util.h index ee0c2383..21eba4c 100644 --- a/content/renderer/pepper/url_response_info_util.h +++ b/content/renderer/pepper/url_response_info_util.h @@ -14,7 +14,6 @@ class WebURLResponse; } namespace content { -class RendererPpapiHostImpl; typedef base::Callback<void(const ppapi::URLResponseInfoData&)> DataFromWebURLResponseCallback; @@ -22,8 +21,7 @@ typedef base::Callback<void(const ppapi::URLResponseInfoData&)> // The returned object will have one plugin reference to the "body_as_file_ref" // if it's non-null. It's expected that the result of this function will be // passed to the plugin. -void DataFromWebURLResponse(RendererPpapiHostImpl* host_impl, - PP_Instance pp_instance, +void DataFromWebURLResponse(PP_Instance pp_instance, const WebKit::WebURLResponse& response, const DataFromWebURLResponseCallback& callback); diff --git a/ppapi/ppapi_proxy.gypi b/ppapi/ppapi_proxy.gypi index e700d2c..884dc15 100644 --- a/ppapi/ppapi_proxy.gypi +++ b/ppapi/ppapi_proxy.gypi @@ -113,6 +113,8 @@ 'proxy/ppb_buffer_proxy.h', 'proxy/ppb_core_proxy.cc', 'proxy/ppb_core_proxy.h', + 'proxy/ppb_file_ref_proxy.cc', + 'proxy/ppb_file_ref_proxy.h', 'proxy/ppb_flash_message_loop_proxy.cc', 'proxy/ppb_flash_message_loop_proxy.h', 'proxy/ppb_graphics_3d_proxy.cc', diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi index f3129f8..1160143 100644 --- a/ppapi/ppapi_shared.gypi +++ b/ppapi/ppapi_shared.gypi @@ -23,9 +23,7 @@ 'shared_impl/file_io_state_manager.h', 'shared_impl/file_path.cc', 'shared_impl/file_path.h', - 'shared_impl/file_ref_create_info.cc', 'shared_impl/file_ref_create_info.h', - 'shared_impl/file_ref_detailed_info.h', 'shared_impl/file_ref_util.cc', 'shared_impl/file_ref_util.h', 'shared_impl/file_type_conversion.cc', @@ -55,6 +53,8 @@ 'shared_impl/ppb_crypto_shared.cc', 'shared_impl/ppb_device_ref_shared.cc', 'shared_impl/ppb_device_ref_shared.h', + 'shared_impl/ppb_file_ref_shared.cc', + 'shared_impl/ppb_file_ref_shared.h', 'shared_impl/ppb_gamepad_shared.cc', 'shared_impl/ppb_gamepad_shared.h', 'shared_impl/ppb_graphics_3d_shared.cc', diff --git a/ppapi/proxy/file_chooser_resource.cc b/ppapi/proxy/file_chooser_resource.cc index 9847e29..ebd545c 100644 --- a/ppapi/proxy/file_chooser_resource.cc +++ b/ppapi/proxy/file_chooser_resource.cc @@ -9,8 +9,8 @@ #include "ipc/ipc_message.h" #include "ppapi/c/pp_errors.h" #include "ppapi/proxy/dispatch_reply_message.h" -#include "ppapi/proxy/file_ref_resource.h" #include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/shared_impl/var.h" namespace ppapi { @@ -100,25 +100,19 @@ void FileChooserResource::PopulateAcceptTypes( void FileChooserResource::OnPluginMsgShowReply( const ResourceMessageReplyParams& params, - const std::vector<FileRefCreateInfo>& chosen_files) { + const std::vector<PPB_FileRef_CreateInfo>& chosen_files) { if (output_.is_valid()) { // Using v0.6 of the API with the output array. std::vector<PP_Resource> files; - for (size_t i = 0; i < chosen_files.size(); i++) { - files.push_back(FileRefResource::CreateFileRef( - connection(), - pp_instance(), - chosen_files[i])); - } + for (size_t i = 0; i < chosen_files.size(); i++) + files.push_back(PPB_FileRef_Proxy::DeserializeFileRef(chosen_files[i])); output_.StoreResourceVector(files); } else { // Convert each of the passed in file infos to resources. These will be // owned by the FileChooser object until they're passed to the plugin. DCHECK(file_queue_.empty()); for (size_t i = 0; i < chosen_files.size(); i++) { - file_queue_.push(FileRefResource::CreateFileRef( - connection(), - pp_instance(), + file_queue_.push(PPB_FileRef_Proxy::DeserializeFileRef( chosen_files[i])); } } diff --git a/ppapi/proxy/file_chooser_resource.h b/ppapi/proxy/file_chooser_resource.h index b744e91..58331db 100644 --- a/ppapi/proxy/file_chooser_resource.h +++ b/ppapi/proxy/file_chooser_resource.h @@ -17,7 +17,7 @@ namespace ppapi { -struct FileRefCreateInfo; +struct PPB_FileRef_CreateInfo; namespace proxy { @@ -56,7 +56,7 @@ class PPAPI_PROXY_EXPORT FileChooserResource private: void OnPluginMsgShowReply( const ResourceMessageReplyParams& params, - const std::vector<FileRefCreateInfo>& chosen_files); + const std::vector<PPB_FileRef_CreateInfo>& chosen_files); int32_t ShowInternal(PP_Bool save_as, const PP_Var& suggested_file_name, diff --git a/ppapi/proxy/file_chooser_resource_unittest.cc b/ppapi/proxy/file_chooser_resource_unittest.cc index e563bf4..a5801ee 100644 --- a/ppapi/proxy/file_chooser_resource_unittest.cc +++ b/ppapi/proxy/file_chooser_resource_unittest.cc @@ -5,7 +5,6 @@ #include "base/message_loop/message_loop.h" #include "ppapi/c/dev/ppb_file_chooser_dev.h" #include "ppapi/c/pp_errors.h" -#include "ppapi/c/ppb_file_ref.h" #include "ppapi/proxy/file_chooser_resource.h" #include "ppapi/proxy/locking_resource_releaser.h" #include "ppapi/proxy/ppapi_messages.h" @@ -92,13 +91,13 @@ TEST_F(FileChooserResourceTest, Show) { reply_params.set_result(PP_OK); // Synthesize a response with one file ref in it. Note that it must have a - // pending_host_resource_id set. Since there isn't actually a host, this can - // be whatever we want. - std::vector<FileRefCreateInfo> create_info_array; - FileRefCreateInfo create_info; - create_info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL; - create_info.display_name = "bar"; - create_info.pending_host_resource_id = 12; + // host resource value set or deserialization will fail. Since there isn't + // actually a host, this can be whatever we want. + std::vector<PPB_FileRef_CreateInfo> create_info_array; + PPB_FileRef_CreateInfo create_info; + create_info.resource.SetHostResource(pp_instance(), 123); + create_info.path = "foo/bar"; + create_info.name = "baz"; create_info_array.push_back(create_info); ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived( PpapiPluginMsg_ResourceReply(reply_params, @@ -116,8 +115,9 @@ TEST_F(FileChooserResourceTest, Show) { { ProxyAutoLock lock; ScopedPPVar release_name_var(ScopedPPVar::PassRef(), name_var); - EXPECT_VAR_IS_STRING("bar", name_var); + EXPECT_VAR_IS_STRING(create_info.name, name_var); } + // Path should be undefined since it's external filesystem. PP_Var path_var(file_ref_iface->GetPath(dest[0])); { ProxyAutoLock lock; diff --git a/ppapi/proxy/file_io_resource.cc b/ppapi/proxy/file_io_resource.cc index f63f906..76ee51c 100644 --- a/ppapi/proxy/file_io_resource.cc +++ b/ppapi/proxy/file_io_resource.cc @@ -111,13 +111,9 @@ int32_t FileIOResource::Open(PP_Resource file_ref, if (rv != PP_OK) return rv; - // Take a reference on the FileRef resource while we're opening the file; we - // don't want the plugin destroying it during the Open operation. - file_ref_ = file_ref; - Call<PpapiPluginMsg_FileIO_OpenReply>(RENDERER, PpapiHostMsg_FileIO_Open( - file_ref, + enter.resource()->host_resource().host_resource(), open_flags), base::Bind(&FileIOResource::OnPluginMsgOpenFileComplete, this, callback)); @@ -414,9 +410,6 @@ void FileIOResource::OnPluginMsgOpenFileComplete( const ResourceMessageReplyParams& params) { DCHECK(state_manager_.get_pending_operation() == FileIOStateManager::OPERATION_EXCLUSIVE); - - // Release the FileRef resource. - file_ref_ = 0; if (params.result() == PP_OK) state_manager_.SetOpenSucceed(); diff --git a/ppapi/proxy/file_io_resource.h b/ppapi/proxy/file_io_resource.h index 139fb83..1a888d1 100644 --- a/ppapi/proxy/file_io_resource.h +++ b/ppapi/proxy/file_io_resource.h @@ -12,7 +12,6 @@ #include "ppapi/proxy/plugin_resource.h" #include "ppapi/proxy/ppapi_proxy_export.h" #include "ppapi/shared_impl/file_io_state_manager.h" -#include "ppapi/shared_impl/scoped_pp_resource.h" #include "ppapi/thunk/ppb_file_io_api.h" namespace ppapi { @@ -138,8 +137,6 @@ class PPAPI_PROXY_EXPORT FileIOResource PP_FileSystemType file_system_type_; FileIOStateManager state_manager_; - ScopedPPResource file_ref_; - DISALLOW_COPY_AND_ASSIGN(FileIOResource); }; diff --git a/ppapi/proxy/file_ref_resource.cc b/ppapi/proxy/file_ref_resource.cc index ae4df85..4c098a5 100644 --- a/ppapi/proxy/file_ref_resource.cc +++ b/ppapi/proxy/file_ref_resource.cc @@ -22,7 +22,7 @@ namespace proxy { FileRefResource::FileRefResource( Connection connection, PP_Instance instance, - const FileRefCreateInfo& create_info) + const FileRef_CreateInfo& create_info) : PluginResource(connection, instance), create_info_(create_info), file_system_resource_(create_info.file_system_plugin_resource) { @@ -34,6 +34,7 @@ FileRefResource::FileRefResource( create_info_.internal_path.erase(path_size - 1, 1); path_var_ = new StringVar(create_info_.internal_path); + create_info_.display_name = GetNameForInternalFilePath( create_info_.internal_path); } @@ -56,7 +57,7 @@ FileRefResource::~FileRefResource() { PP_Resource FileRefResource::CreateFileRef( Connection connection, PP_Instance instance, - const FileRefCreateInfo& create_info) { + const FileRef_CreateInfo& create_info) { // If we have a valid file_system resource, ensure that its type matches that // of the fs_type parameter. if (create_info.file_system_plugin_resource != 0) { @@ -81,7 +82,9 @@ PP_Resource FileRefResource::CreateFileRef( } thunk::PPB_FileRef_API* FileRefResource::AsPPB_FileRef_API() { - return this; + // TODO: return "this" once we update PPB_FileRef_API. + NOTREACHED(); + return NULL; } PP_FileSystemType FileRefResource::GetFileSystemType() const { @@ -108,7 +111,7 @@ PP_Resource FileRefResource::GetParent() { pos++; std::string parent_path = create_info_.internal_path.substr(0, pos); - ppapi::FileRefCreateInfo parent_info; + ppapi::FileRef_CreateInfo parent_info; parent_info.file_system_type = create_info_.file_system_type; parent_info.internal_path = parent_path; parent_info.display_name = GetNameForInternalFilePath(parent_path); @@ -181,9 +184,33 @@ int32_t FileRefResource::ReadDirectoryEntries( return PP_OK_COMPLETIONPENDING; } -const FileRefCreateInfo& FileRefResource::GetCreateInfo() const { +/* +const FileRef_CreateInfo& FileRefResource::GetCreateInfo() const { return create_info_; } +*/ +const PPB_FileRef_CreateInfo& FileRefResource::GetCreateInfo() const { + // FIXME + NOTREACHED(); + PPB_FileRef_CreateInfo *info = new PPB_FileRef_CreateInfo(); + return *info; +} + +// TODO(teravest): Remove this when we are finished moving to the new proxy. +int32_t FileRefResource::QueryInHost(linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback) { + NOTREACHED(); + return PP_ERROR_FAILED; +} + +// TODO(teravest): Remove this when we are finished moving to the new proxy. +int32_t FileRefResource::ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<TrackedCallback> callback) { + NOTREACHED(); + return PP_ERROR_FAILED; +} PP_Var FileRefResource::GetAbsolutePath() { if (!absolute_path_var_.get()) { @@ -221,7 +248,7 @@ void FileRefResource::OnDirectoryEntriesReply( const PP_ArrayOutput& output, scoped_refptr<TrackedCallback> callback, const ResourceMessageReplyParams& params, - const std::vector<ppapi::FileRefCreateInfo>& infos, + const std::vector<ppapi::FileRef_CreateInfo>& infos, const std::vector<PP_FileType>& file_types) { if (!TrackedCallback::IsPending(callback)) return; diff --git a/ppapi/proxy/file_ref_resource.h b/ppapi/proxy/file_ref_resource.h index f982438..82570fb 100644 --- a/ppapi/proxy/file_ref_resource.h +++ b/ppapi/proxy/file_ref_resource.h @@ -29,7 +29,7 @@ class PPAPI_PROXY_EXPORT FileRefResource public: static PP_Resource CreateFileRef(Connection connection, PP_Instance instance, - const FileRefCreateInfo& info); + const FileRef_CreateInfo& info); virtual ~FileRefResource(); @@ -55,7 +55,13 @@ class PPAPI_PROXY_EXPORT FileRefResource virtual int32_t ReadDirectoryEntries( const PP_ArrayOutput& output, scoped_refptr<TrackedCallback> callback) OVERRIDE; - virtual const FileRefCreateInfo& GetCreateInfo() const OVERRIDE; + virtual const PPB_FileRef_CreateInfo& GetCreateInfo() const OVERRIDE; + virtual int32_t QueryInHost(linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<TrackedCallback> callback) OVERRIDE; // Private API virtual PP_Var GetAbsolutePath() OVERRIDE; @@ -63,7 +69,7 @@ class PPAPI_PROXY_EXPORT FileRefResource private: FileRefResource(Connection connection, PP_Instance instance, - const FileRefCreateInfo& info); + const FileRef_CreateInfo& info); void RunTrackedCallback(scoped_refptr<TrackedCallback> callback, const ResourceMessageReplyParams& params); @@ -77,11 +83,11 @@ class PPAPI_PROXY_EXPORT FileRefResource const PP_ArrayOutput& output, scoped_refptr<TrackedCallback> callback, const ResourceMessageReplyParams& params, - const std::vector<ppapi::FileRefCreateInfo>& infos, + const std::vector<ppapi::FileRef_CreateInfo>& infos, const std::vector<PP_FileType>& file_types); // Populated after creation. - FileRefCreateInfo create_info_; + FileRef_CreateInfo create_info_; // Some file ref operations may fail if the the file system resource inside // create_info_ is destroyed. Therefore, we explicitly hold a reference to diff --git a/ppapi/proxy/flash_drm_resource.cc b/ppapi/proxy/flash_drm_resource.cc index 889aa72..a4be23b 100644 --- a/ppapi/proxy/flash_drm_resource.cc +++ b/ppapi/proxy/flash_drm_resource.cc @@ -7,8 +7,9 @@ #include "base/bind.h" #include "ppapi/c/pp_errors.h" #include "ppapi/proxy/dispatch_reply_message.h" -#include "ppapi/proxy/file_ref_resource.h" #include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" +#include "ppapi/shared_impl/ppb_file_ref_shared.h" #include "ppapi/shared_impl/var.h" namespace ppapi { @@ -87,14 +88,10 @@ void FlashDRMResource::OnPluginMsgGetVoucherFileReply( PP_Resource* dest, scoped_refptr<TrackedCallback> callback, const ResourceMessageReplyParams& params, - const FileRefCreateInfo& file_info) { + const PPB_FileRef_CreateInfo& file_info) { if (TrackedCallback::IsPending(callback)) { - if (params.result() == PP_OK) { - *dest = FileRefResource::CreateFileRef( - connection(), - pp_instance(), - file_info); - } + if (params.result() == PP_OK) + *dest = PPB_FileRef_Proxy::DeserializeFileRef(file_info); callback->Run(params.result()); } } diff --git a/ppapi/proxy/flash_drm_resource.h b/ppapi/proxy/flash_drm_resource.h index 9a4b31c..12c71e8 100644 --- a/ppapi/proxy/flash_drm_resource.h +++ b/ppapi/proxy/flash_drm_resource.h @@ -11,7 +11,7 @@ #include "ppapi/thunk/ppb_flash_drm_api.h" namespace ppapi { -struct FileRefCreateInfo; +struct PPB_FileRef_CreateInfo; } namespace ppapi { @@ -44,7 +44,7 @@ class FlashDRMResource void OnPluginMsgGetVoucherFileReply(PP_Resource* dest, scoped_refptr<TrackedCallback> callback, const ResourceMessageReplyParams& params, - const FileRefCreateInfo& file_info); + const PPB_FileRef_CreateInfo& file_info); DISALLOW_COPY_AND_ASSIGN(FlashDRMResource); }; diff --git a/ppapi/proxy/flash_file_resource.cc b/ppapi/proxy/flash_file_resource.cc index ce7a2ce..1387eb7 100644 --- a/ppapi/proxy/flash_file_resource.cc +++ b/ppapi/proxy/flash_file_resource.cc @@ -13,7 +13,6 @@ #include "ppapi/shared_impl/time_conversion.h" #include "ppapi/shared_impl/var.h" #include "ppapi/thunk/enter.h" -#include "ppapi/thunk/ppb_file_ref_api.h" namespace ppapi { namespace proxy { diff --git a/ppapi/proxy/interface_list.cc b/ppapi/proxy/interface_list.cc index 49ec0eb..d9feb89 100644 --- a/ppapi/proxy/interface_list.cc +++ b/ppapi/proxy/interface_list.cc @@ -101,6 +101,7 @@ #include "ppapi/proxy/ppb_broker_proxy.h" #include "ppapi/proxy/ppb_buffer_proxy.h" #include "ppapi/proxy/ppb_core_proxy.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/proxy/ppb_flash_message_loop_proxy.h" #include "ppapi/proxy/ppb_graphics_3d_proxy.h" #include "ppapi/proxy/ppb_image_data_proxy.h" diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h index c97ae7a..3767f8f 100644 --- a/ppapi/proxy/ppapi_messages.h +++ b/ppapi/proxy/ppapi_messages.h @@ -57,7 +57,6 @@ #include "ppapi/shared_impl/dir_contents.h" #include "ppapi/shared_impl/file_path.h" #include "ppapi/shared_impl/file_ref_create_info.h" -#include "ppapi/shared_impl/file_ref_detailed_info.h" #include "ppapi/shared_impl/ppapi_nacl_channel_args.h" #include "ppapi/shared_impl/ppapi_preferences.h" #include "ppapi/shared_impl/ppb_device_ref_shared.h" @@ -203,7 +202,7 @@ IPC_STRUCT_TRAITS_BEGIN(ppapi::DirEntry) IPC_STRUCT_TRAITS_MEMBER(is_dir) IPC_STRUCT_TRAITS_END() -IPC_STRUCT_TRAITS_BEGIN(ppapi::FileRefCreateInfo) +IPC_STRUCT_TRAITS_BEGIN(ppapi::FileRef_CreateInfo) IPC_STRUCT_TRAITS_MEMBER(file_system_type) IPC_STRUCT_TRAITS_MEMBER(internal_path) IPC_STRUCT_TRAITS_MEMBER(display_name) @@ -211,13 +210,6 @@ IPC_STRUCT_TRAITS_BEGIN(ppapi::FileRefCreateInfo) IPC_STRUCT_TRAITS_MEMBER(file_system_plugin_resource) IPC_STRUCT_TRAITS_END() -IPC_STRUCT_TRAITS_BEGIN(ppapi::FileRefDetailedInfo) - IPC_STRUCT_TRAITS_MEMBER(resource) - IPC_STRUCT_TRAITS_MEMBER(file_system_type) - IPC_STRUCT_TRAITS_MEMBER(file_system_url_spec) - IPC_STRUCT_TRAITS_MEMBER(external_path) -IPC_STRUCT_TRAITS_END() - IPC_STRUCT_TRAITS_BEGIN(ppapi::FlashSiteSetting) IPC_STRUCT_TRAITS_MEMBER(site) IPC_STRUCT_TRAITS_MEMBER(permission) @@ -306,7 +298,8 @@ IPC_STRUCT_TRAITS_END() IPC_STRUCT_TRAITS_BEGIN(ppapi::URLRequestInfoData::BodyItem) IPC_STRUCT_TRAITS_MEMBER(is_file) IPC_STRUCT_TRAITS_MEMBER(data) - IPC_STRUCT_TRAITS_MEMBER(file_ref_pp_resource) + // Note: we don't serialize file_ref. + IPC_STRUCT_TRAITS_MEMBER(file_ref_host_resource) IPC_STRUCT_TRAITS_MEMBER(start_offset) IPC_STRUCT_TRAITS_MEMBER(number_of_bytes) IPC_STRUCT_TRAITS_MEMBER(expected_last_modified_time) @@ -493,6 +486,30 @@ IPC_MESSAGE_ROUTED4(PpapiMsg_PPBAudio_NotifyAudioStreamCreated, ppapi::proxy::SerializedHandle /* socket_handle */, ppapi::proxy::SerializedHandle /* handle */) +// PPB_FileRef. +// TODO(teravest): Remove these messages when we've switched over to the "new" +// proxy. +IPC_MESSAGE_ROUTED3( + PpapiMsg_PPBFileRef_CallbackComplete, + ppapi::HostResource /* resource */, + uint32_t /* callback_id */, + int32_t /* result */) + +IPC_MESSAGE_ROUTED4( + PpapiMsg_PPBFileRef_QueryCallbackComplete, + ppapi::HostResource /* resource */, + PP_FileInfo /* file_info */, + uint32_t /* callback_id */, + int32_t /* result */) + +IPC_MESSAGE_ROUTED5( + PpapiMsg_PPBFileRef_ReadDirectoryEntriesCallbackComplete, + ppapi::HostResource /* resource */, + std::vector<ppapi::PPB_FileRef_CreateInfo> /* files */, + std::vector<PP_FileType> /* file_types */, + uint32_t /* callback_id */, + int32_t /* result */) + // PPB_FileSystem. IPC_MESSAGE_ROUTED2( PpapiMsg_PPBFileSystem_OpenComplete, @@ -781,6 +798,43 @@ IPC_MESSAGE_ROUTED1(PpapiHostMsg_PPBCore_AddRefResource, IPC_MESSAGE_ROUTED1(PpapiHostMsg_PPBCore_ReleaseResource, ppapi::HostResource) +// PPB_FileRef. +// TODO(teravest): Remove these messages when we've switched over to the "new" +// proxy. +IPC_SYNC_MESSAGE_ROUTED3_1(PpapiHostMsg_PPBFileRef_Create, + PP_Instance /* instance */, + PP_Resource /* file_system */, + std::string /* path */, + ppapi::PPB_FileRef_CreateInfo /* result */) +IPC_SYNC_MESSAGE_ROUTED1_1(PpapiHostMsg_PPBFileRef_GetParent, + ppapi::HostResource /* file_ref */, + ppapi::PPB_FileRef_CreateInfo /* result */) +IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileRef_MakeDirectory, + ppapi::HostResource /* file_ref */, + PP_Bool /* make_ancestors */, + uint32_t /* callback_id */) +IPC_MESSAGE_ROUTED4(PpapiHostMsg_PPBFileRef_Touch, + ppapi::HostResource /* file_ref */, + PP_Time /* last_access */, + PP_Time /* last_modified */, + uint32_t /* callback_id */) +IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFileRef_Delete, + ppapi::HostResource /* file_ref */, + uint32_t /* callback_id */) +IPC_MESSAGE_ROUTED3(PpapiHostMsg_PPBFileRef_Rename, + ppapi::HostResource /* file_ref */, + ppapi::HostResource /* new_file_ref */, + uint32_t /* callback_id */) +IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFileRef_Query, + ppapi::HostResource /* file_ref */, + uint32_t /* callback_id */) +IPC_SYNC_MESSAGE_ROUTED1_1(PpapiHostMsg_PPBFileRef_GetAbsolutePath, + ppapi::HostResource /* file_ref */, + ppapi::proxy::SerializedVar /* result */) +IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFileRef_ReadDirectoryEntries, + ppapi::HostResource /* file_ref */, + uint32_t /* callback_id */) + // PPB_Graphics3D. IPC_SYNC_MESSAGE_ROUTED3_1(PpapiHostMsg_PPBGraphics3D_Create, PP_Instance /* instance */, @@ -1213,6 +1267,7 @@ IPC_MESSAGE_ROUTED2( ppapi::proxy::ResourceMessageReplyParams /* reply_params */, IPC::Message /* nested_msg */) + IPC_SYNC_MESSAGE_CONTROL2_2(PpapiHostMsg_ResourceSyncCall, ppapi::proxy::ResourceMessageCallParams /* call_params */, IPC::Message /* nested_msg */, @@ -1286,7 +1341,7 @@ IPC_MESSAGE_CONTROL4(PpapiHostMsg_FileChooser_Show, std::string /* suggested_file_name */, std::vector<std::string> /* accept_mime_types */) IPC_MESSAGE_CONTROL1(PpapiPluginMsg_FileChooser_ShowReply, - std::vector<ppapi::FileRefCreateInfo> /* files */) + std::vector<ppapi::PPB_FileRef_CreateInfo> /* files */) // FileIO IPC_MESSAGE_CONTROL0(PpapiHostMsg_FileIO_Create) @@ -1362,10 +1417,10 @@ IPC_MESSAGE_CONTROL1(PpapiPluginMsg_FileRef_QueryReply, // location indicated by the FileRef. IPC_MESSAGE_CONTROL0(PpapiHostMsg_FileRef_ReadDirectoryEntries) -// FileRefCreateInfo does not provide file type information, so two +// FileRef_CreateInfo does not provide file type information, so two // corresponding vectors are returned. IPC_MESSAGE_CONTROL2(PpapiPluginMsg_FileRef_ReadDirectoryEntriesReply, - std::vector<ppapi::FileRefCreateInfo> /* files */, + std::vector<ppapi::FileRef_CreateInfo> /* files */, std::vector<PP_FileType> /* file_types */) // Requests that the browser reply with the absolute path to the indicated @@ -1405,7 +1460,7 @@ IPC_MESSAGE_CONTROL0(PpapiHostMsg_FlashDRM_GetVoucherFile) // Reply message for GetVoucherFile which contains the CreateInfo for a // PPB_FileRef which points to the voucher file. IPC_MESSAGE_CONTROL1(PpapiPluginMsg_FlashDRM_GetVoucherFileReply, - ppapi::FileRefCreateInfo /* file_info */) + ppapi::PPB_FileRef_CreateInfo /* file_info */) // Gamepad. IPC_MESSAGE_CONTROL0(PpapiHostMsg_Gamepad_Create) @@ -1767,18 +1822,12 @@ IPC_MESSAGE_CONTROL4(PpapiHostMsg_FileRef_GetInfoForRenderer, // path information in either |file_system_url_spec| (for internal file systems) // or |external_path| (for external file systems). // Only sent from the browser to the renderer. -IPC_MESSAGE_ROUTED2( - PpapiHostMsg_FileRef_GetInfoForRendererReply, - int32_t /* sequence */, - std::vector<ppapi::FileRefDetailedInfo> /* detailed_info */) - -// A synchronous version of the two above messages. This is required to support -// some URL loading routes which must be executed synchronously. -IPC_SYNC_MESSAGE_ROUTED2_1( - PpapiHostMsg_FileRef_SyncGetInfoForRenderer, - int /* child_process_id */, - std::vector<PP_Resource> /* resources */, - std::vector<ppapi::FileRefDetailedInfo> /* detailed_info */) +IPC_MESSAGE_ROUTED5(PpapiHostMsg_FileRef_GetInfoForRendererReply, + int32_t /* sequence */, + std::vector<PP_Resource> /* resources */, + std::vector<PP_FileSystemType> /* fs_type */, + std::vector<std::string> /* file_system_url_spec */, + std::vector<base::FilePath> /* external_path */) // Flash ----------------------------------------------------------------------- diff --git a/ppapi/proxy/ppapi_param_traits.cc b/ppapi/proxy/ppapi_param_traits.cc index 5d4345f..ca25f82 100644 --- a/ppapi/proxy/ppapi_param_traits.cc +++ b/ppapi/proxy/ppapi_param_traits.cc @@ -175,6 +175,36 @@ void ParamTraits<PP_NetAddress_Private>::Log(const param_type& p, l->append(" bytes)>"); } +// TODO(teravest): Remove this when FileRef is moved to the "new" proxy. +// PPB_FileRef_CreateInfo ------------------------------------------------------ + +// static +void ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Write(Message* m, + const param_type& p) { + ParamTraits<ppapi::HostResource>::Write(m, p.resource); + ParamTraits<int>::Write(m, p.file_system_type); + ParamTraits<std::string>::Write(m, p.path); + ParamTraits<std::string>::Write(m, p.name); + ParamTraits<PP_Resource>::Write(m, p.file_system_plugin_resource); +} + +// static +bool ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Read(const Message* m, + PickleIterator* iter, + param_type* r) { + return + ParamTraits<ppapi::HostResource>::Read(m, iter, &r->resource) && + ParamTraits<int>::Read(m, iter, &r->file_system_type) && + ParamTraits<std::string>::Read(m, iter, &r->path) && + ParamTraits<std::string>::Read(m, iter, &r->name) && + ParamTraits<PP_Resource>::Read(m, iter, &r->file_system_plugin_resource); +} + +// static +void ParamTraits<ppapi::PPB_FileRef_CreateInfo>::Log(const param_type& p, + std::string* l) { +} + // HostResource ---------------------------------------------------------------- // static @@ -244,6 +274,28 @@ void ParamTraits< std::vector<ppapi::proxy::SerializedVar> >::Log( std::string* l) { } +// std::vector<PPB_FileRef_CreateInfo> ----------------------------------------- + +void ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Write( + Message* m, + const param_type& p) { + WriteVectorWithoutCopy(m, p); +} + +// static +bool ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Read( + const Message* m, + PickleIterator* iter, + param_type* r) { + return ReadVectorWithoutCopy(m, iter, r); +} + +// static +void ParamTraits< std::vector<ppapi::PPB_FileRef_CreateInfo> >::Log( + const param_type& p, + std::string* l) { +} + // ppapi::PpapiPermissions ----------------------------------------------------- void ParamTraits<ppapi::PpapiPermissions>::Write(Message* m, diff --git a/ppapi/proxy/ppapi_param_traits.h b/ppapi/proxy/ppapi_param_traits.h index b56ec3e..f56415a8 100644 --- a/ppapi/proxy/ppapi_param_traits.h +++ b/ppapi/proxy/ppapi_param_traits.h @@ -17,6 +17,7 @@ #include "ppapi/shared_impl/file_path.h" #include "ppapi/shared_impl/file_ref_create_info.h" #include "ppapi/shared_impl/ppapi_permissions.h" +#include "ppapi/shared_impl/ppb_file_ref_shared.h" #include "ppapi/shared_impl/socket_option_data.h" struct PP_FileInfo; @@ -76,6 +77,15 @@ struct PPAPI_PROXY_EXPORT ParamTraits< static void Log(const param_type& p, std::string* l); }; +// TODO(teravest): Remove this when we've switched over to the new proxy. +template<> +struct PPAPI_PROXY_EXPORT ParamTraits<ppapi::PPB_FileRef_CreateInfo> { + typedef ppapi::PPB_FileRef_CreateInfo param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + template<> struct PPAPI_PROXY_EXPORT ParamTraits< ppapi::proxy::PPBURLLoader_UpdateProgress_Params> { @@ -144,6 +154,15 @@ struct PPAPI_PROXY_EXPORT ParamTraits< }; template<> +struct PPAPI_PROXY_EXPORT ParamTraits< std::vector< + ppapi::PPB_FileRef_CreateInfo> > { + typedef std::vector<ppapi::PPB_FileRef_CreateInfo> param_type; + static void Write(Message* m, const param_type& p); + static bool Read(const Message* m, PickleIterator* iter, param_type* r); + static void Log(const param_type& p, std::string* l); +}; + +template<> struct PPAPI_PROXY_EXPORT ParamTraits<ppapi::PpapiPermissions> { typedef ppapi::PpapiPermissions param_type; static void Write(Message* m, const param_type& p); diff --git a/ppapi/proxy/ppb_file_ref_proxy.cc b/ppapi/proxy/ppb_file_ref_proxy.cc new file mode 100644 index 0000000..62c55da --- /dev/null +++ b/ppapi/proxy/ppb_file_ref_proxy.cc @@ -0,0 +1,549 @@ +// Copyright (c) 2012 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_file_ref_proxy.h" + +#include <map> + +#include "base/bind.h" +#include "ppapi/c/pp_directory_entry.h" +#include "ppapi/c/pp_errors.h" +#include "ppapi/c/ppb_file_ref.h" +#include "ppapi/c/private/ppb_file_ref_private.h" +#include "ppapi/c/private/ppb_proxy_private.h" +#include "ppapi/proxy/enter_proxy.h" +#include "ppapi/proxy/host_dispatcher.h" +#include "ppapi/proxy/plugin_dispatcher.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/serialized_var.h" +#include "ppapi/shared_impl/array_writer.h" +#include "ppapi/shared_impl/ppb_file_ref_shared.h" +#include "ppapi/shared_impl/scoped_pp_resource.h" +#include "ppapi/shared_impl/tracked_callback.h" +#include "ppapi/thunk/resource_creation_api.h" +#include "ppapi/thunk/thunk.h" + +using ppapi::thunk::EnterResourceNoLock; +using ppapi::thunk::PPB_FileRef_API; +using ppapi::thunk::ResourceCreationAPI; + +namespace ppapi { +namespace proxy { + +namespace { + +void ReleaseEntries(const std::vector<PP_DirectoryEntry>& entries) { + ResourceTracker* tracker = PpapiGlobals::Get()->GetResourceTracker(); + for (std::vector<PP_DirectoryEntry>::const_iterator it = entries.begin(); + it != entries.end(); ++it) + tracker->ReleaseResource(it->file_ref); +} + +} // namespace + +class FileRef : public PPB_FileRef_Shared { + public: + explicit FileRef(const PPB_FileRef_CreateInfo& info); + virtual ~FileRef(); + + // Resource overrides. + virtual void LastPluginRefWasDeleted() OVERRIDE; + + // PPB_FileRef_API implementation (not provided by PPB_FileRef_Shared). + virtual PP_Resource GetParent() OVERRIDE; + virtual int32_t MakeDirectory( + PP_Bool make_ancestors, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t Touch(PP_Time last_access_time, + PP_Time last_modified_time, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t Delete(scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t Rename(PP_Resource new_file_ref, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t Query(PP_FileInfo* info, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t ReadDirectoryEntries( + const PP_ArrayOutput& output, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t QueryInHost( + linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual int32_t ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + virtual PP_Var GetAbsolutePath() OVERRIDE; + + // Executes the pending callback with the given ID. See pending_callbacks_. + void ExecuteCallback(uint32_t callback_id, int32_t result); + int32_t SetFileInfo(uint32_t callback_id, const PP_FileInfo& info); + int32_t SetReadDirectoryEntriesOutput( + uint32_t callback_id, + const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos, + const std::vector<PP_FileType>& file_types); + + private: + PluginDispatcher* GetDispatcher() const { + return PluginDispatcher::GetForResource(this); + } + + // Adds a callback to the list and returns its ID. + uint32_t SendCallback(scoped_refptr<TrackedCallback> callback); + + // This class can have any number of out-standing requests with completion + // callbacks, in contrast to most resources which have one possible pending + // callback pending (like a Flush callback). + // + // To keep track of them, assign integer IDs to the callbacks, which is how + // the callback will be identified when it's passed to the host and then + // back here. Use unsigned so that overflow is well-defined. + uint32_t next_callback_id_; + typedef std::map<uint32_t, + scoped_refptr<TrackedCallback> > PendingCallbackMap; + PendingCallbackMap pending_callbacks_; + + // Used to keep pointers to PP_FileInfo instances that are written before + // callbacks are invoked. The id of a pending file info will match that of + // the corresponding callback. + typedef std::map<uint32_t, PP_FileInfo*> PendingFileInfoMap; + PendingFileInfoMap pending_file_infos_; + + // Used to keep PP_ArrayOutput instances that are written before callbacks + // are invoked. The id of a pending array output will match that of the + // corresponding callback. + typedef std::map<uint32_t, PP_ArrayOutput> + PendingReadDirectoryEntriesOutputMap; + PendingReadDirectoryEntriesOutputMap pending_read_entries_outputs_; + + // Holds a reference on plugin side when running out of process, so that + // FileSystem won't die before FileRef. See PPB_FileRef_Impl for + // corresponding code for in-process mode. Note that this workaround will + // be no longer needed after FileRef refactoring. + ScopedPPResource file_system_; + + DISALLOW_IMPLICIT_CONSTRUCTORS(FileRef); +}; + +FileRef::FileRef(const PPB_FileRef_CreateInfo& info) + : PPB_FileRef_Shared(OBJECT_IS_PROXY, info), + next_callback_id_(0u), + file_system_(info.file_system_plugin_resource) { +} + +FileRef::~FileRef() { + // The callbacks map should have been cleared by LastPluginRefWasDeleted. + DCHECK(pending_callbacks_.empty()); + DCHECK(pending_file_infos_.empty()); + DCHECK(pending_read_entries_outputs_.empty()); +} + +void FileRef::LastPluginRefWasDeleted() { + // The callback tracker will abort our callbacks for us. + pending_callbacks_.clear(); + pending_file_infos_.clear(); + pending_read_entries_outputs_.clear(); +} + +PP_Resource FileRef::GetParent() { + PPB_FileRef_CreateInfo create_info; + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_GetParent( + API_ID_PPB_FILE_REF, host_resource(), &create_info)); + return PPB_FileRef_Proxy::DeserializeFileRef(create_info); +} + +int32_t FileRef::MakeDirectory(PP_Bool make_ancestors, + scoped_refptr<TrackedCallback> callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_MakeDirectory( + API_ID_PPB_FILE_REF, host_resource(), make_ancestors, + SendCallback(callback))); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileRef::Touch(PP_Time last_access_time, + PP_Time last_modified_time, + scoped_refptr<TrackedCallback> callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Touch( + API_ID_PPB_FILE_REF, host_resource(), last_access_time, + last_modified_time, SendCallback(callback))); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileRef::Delete(scoped_refptr<TrackedCallback> callback) { + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Delete( + API_ID_PPB_FILE_REF, host_resource(), SendCallback(callback))); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileRef::Rename(PP_Resource new_file_ref, + scoped_refptr<TrackedCallback> callback) { + Resource* new_file_ref_object = + PpapiGlobals::Get()->GetResourceTracker()->GetResource(new_file_ref); + if (!new_file_ref_object || + new_file_ref_object->host_resource().instance() != pp_instance()) + return PP_ERROR_BADRESOURCE; + + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Rename( + API_ID_PPB_FILE_REF, host_resource(), + new_file_ref_object->host_resource(), SendCallback(callback))); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileRef::Query(PP_FileInfo* info, + scoped_refptr<TrackedCallback> callback) { + // Store the pending file info id. + uint32_t id = SendCallback(callback); + pending_file_infos_[id] = info; + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_Query( + API_ID_PPB_FILE_REF, host_resource(), id)); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileRef::ReadDirectoryEntries( + const PP_ArrayOutput& output, + scoped_refptr<TrackedCallback> callback) { + // Store the pending read entries output id. + uint32_t id = SendCallback(callback); + pending_read_entries_outputs_[id] = output; + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_ReadDirectoryEntries( + API_ID_PPB_FILE_REF, host_resource(), id)); + return PP_OK_COMPLETIONPENDING; +} + +int32_t FileRef::QueryInHost( + linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback) { + NOTREACHED(); + return PP_ERROR_FAILED; +} + +int32_t FileRef::ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<TrackedCallback> callback) { + NOTREACHED(); + return PP_ERROR_FAILED; +} + +PP_Var FileRef::GetAbsolutePath() { + ReceiveSerializedVarReturnValue result; + GetDispatcher()->Send(new PpapiHostMsg_PPBFileRef_GetAbsolutePath( + API_ID_PPB_FILE_REF, host_resource(), &result)); + return result.Return(GetDispatcher()); +} + +void FileRef::ExecuteCallback(uint32_t callback_id, int32_t result) { + PendingCallbackMap::iterator found = pending_callbacks_.find(callback_id); + if (found == pending_callbacks_.end()) { + // This will happen when the plugin deletes its resource with a pending + // callback. The callback will be locally issued with an ABORTED call while + // the operation may still be pending in the renderer. + return; + } + + // Executing the callback may mutate the callback list. + scoped_refptr<TrackedCallback> callback = found->second; + pending_callbacks_.erase(found); + callback->Run(result); +} + +int32_t FileRef::SetFileInfo(uint32_t callback_id, const PP_FileInfo& info) { + PendingFileInfoMap::iterator found = pending_file_infos_.find(callback_id); + if (found == pending_file_infos_.end()) + return PP_ERROR_FAILED; + PP_FileInfo* target_info = found->second; + *target_info = info; + pending_file_infos_.erase(found); + return PP_OK; +} + +int32_t FileRef::SetReadDirectoryEntriesOutput( + uint32_t callback_id, + const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos, + const std::vector<PP_FileType>& file_types) { + PendingReadDirectoryEntriesOutputMap::iterator found = + pending_read_entries_outputs_.find(callback_id); + if (found == pending_read_entries_outputs_.end()) + return PP_ERROR_FAILED; + + PP_ArrayOutput output = found->second; + pending_read_entries_outputs_.erase(found); + + std::vector<PP_DirectoryEntry> entries; + for (size_t i = 0; i < infos.size(); ++i) { + PP_DirectoryEntry entry; + entry.file_ref = PPB_FileRef_Proxy::DeserializeFileRef(infos[i]); + entry.file_type = file_types[i]; + entries.push_back(entry); + } + + ArrayWriter writer(output); + if (!writer.is_valid()) { + ReleaseEntries(entries); + return PP_ERROR_BADARGUMENT; + } + + writer.StoreVector(entries); + return PP_OK; +} + +uint32_t FileRef::SendCallback(scoped_refptr<TrackedCallback> callback) { + // In extreme cases the IDs may wrap around, so avoid duplicates. + while (pending_callbacks_.count(next_callback_id_)) + ++next_callback_id_; + + pending_callbacks_[next_callback_id_] = callback; + return next_callback_id_++; +} + +PPB_FileRef_Proxy::PPB_FileRef_Proxy(Dispatcher* dispatcher) + : InterfaceProxy(dispatcher), + callback_factory_(this) { +} + +PPB_FileRef_Proxy::~PPB_FileRef_Proxy() { +} + +// static +PP_Resource PPB_FileRef_Proxy::CreateProxyResource(PP_Instance instance, + PP_Resource file_system, + const char* path) { + PPB_FileRef_CreateInfo create_info; + PluginDispatcher::GetForInstance(instance)->Send( + new PpapiHostMsg_PPBFileRef_Create( + API_ID_PPB_FILE_REF, instance, file_system, path, &create_info)); + return PPB_FileRef_Proxy::DeserializeFileRef(create_info); +} + +bool PPB_FileRef_Proxy::OnMessageReceived(const IPC::Message& msg) { + bool handled = true; + IPC_BEGIN_MESSAGE_MAP(PPB_FileRef_Proxy, msg) +#if !defined(OS_NACL) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Create, OnMsgCreate) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_GetParent, OnMsgGetParent) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_MakeDirectory, + OnMsgMakeDirectory) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Touch, OnMsgTouch) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Delete, OnMsgDelete) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Rename, OnMsgRename) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_Query, OnMsgQuery) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_ReadDirectoryEntries, + OnMsgReadDirectoryEntries) + IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFileRef_GetAbsolutePath, + OnMsgGetAbsolutePath) +#endif // !defined(OS_NACL) + + IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileRef_CallbackComplete, + OnMsgCallbackComplete) + IPC_MESSAGE_HANDLER(PpapiMsg_PPBFileRef_QueryCallbackComplete, + OnMsgQueryCallbackComplete) + IPC_MESSAGE_HANDLER( + PpapiMsg_PPBFileRef_ReadDirectoryEntriesCallbackComplete, + OnMsgReadDirectoryEntriesCallbackComplete) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP() + return handled; +} + +// static +void PPB_FileRef_Proxy::SerializeFileRef(PP_Resource file_ref, + PPB_FileRef_CreateInfo* result) { + EnterResourceNoLock<PPB_FileRef_API> enter(file_ref, false); + if (enter.succeeded()) + *result = enter.object()->GetCreateInfo(); +} + +// static +PP_Resource PPB_FileRef_Proxy::DeserializeFileRef( + const PPB_FileRef_CreateInfo& serialized) { + if (serialized.resource.is_null()) + return 0; // Resource invalid. + return (new FileRef(serialized))->GetReference(); +} + +#if !defined(OS_NACL) +void PPB_FileRef_Proxy::OnMsgCreate(PP_Instance pp_instance, + PP_Resource file_system, + const std::string& path, + PPB_FileRef_CreateInfo* result) { + thunk::EnterResourceCreation enter(pp_instance); + if (enter.failed()) + return; + + PP_Resource resource = enter.functions()->CreateFileRef( + pp_instance, file_system, path.c_str()); + if (!resource) + return; // CreateInfo default constructor initializes to 0. + SerializeFileRef(resource, result); +} + +void PPB_FileRef_Proxy::OnMsgGetParent(const HostResource& host_resource, + PPB_FileRef_CreateInfo* result) { + EnterHostFromHostResource<PPB_FileRef_API> enter(host_resource); + if (enter.succeeded()) + SerializeFileRef(enter.object()->GetParent(), result); +} + +void PPB_FileRef_Proxy::OnMsgMakeDirectory(const HostResource& host_resource, + PP_Bool make_ancestors, + uint32_t callback_id) { + EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter( + host_resource, callback_factory_, + &PPB_FileRef_Proxy::OnCallbackCompleteInHost, host_resource, callback_id); + if (enter.succeeded()) { + enter.SetResult(enter.object()->MakeDirectory(make_ancestors, + enter.callback())); + } +} + +void PPB_FileRef_Proxy::OnMsgTouch(const HostResource& host_resource, + PP_Time last_access, + PP_Time last_modified, + uint32_t callback_id) { + EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter( + host_resource, callback_factory_, + &PPB_FileRef_Proxy::OnCallbackCompleteInHost, host_resource, callback_id); + if (enter.succeeded()) { + enter.SetResult(enter.object()->Touch(last_access, last_modified, + enter.callback())); + } +} + +void PPB_FileRef_Proxy::OnMsgDelete(const HostResource& host_resource, + uint32_t callback_id) { + EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter( + host_resource, callback_factory_, + &PPB_FileRef_Proxy::OnCallbackCompleteInHost, host_resource, callback_id); + if (enter.succeeded()) + enter.SetResult(enter.object()->Delete(enter.callback())); +} + +void PPB_FileRef_Proxy::OnMsgRename(const HostResource& file_ref, + const HostResource& new_file_ref, + uint32_t callback_id) { + EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter( + file_ref, callback_factory_, + &PPB_FileRef_Proxy::OnCallbackCompleteInHost, file_ref, callback_id); + if (enter.succeeded()) { + enter.SetResult(enter.object()->Rename(new_file_ref.host_resource(), + enter.callback())); + } +} + +void PPB_FileRef_Proxy::OnMsgQuery(const HostResource& file_ref, + uint32_t callback_id) { + linked_ptr<PP_FileInfo> info(new PP_FileInfo()); + EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter( + file_ref, callback_factory_, + &PPB_FileRef_Proxy::OnQueryCallbackCompleteInHost, file_ref, + info, callback_id); + if (enter.succeeded()) + enter.SetResult(enter.object()->QueryInHost(info, enter.callback())); +} + +void PPB_FileRef_Proxy::OnMsgGetAbsolutePath(const HostResource& host_resource, + SerializedVarReturnValue result) { + EnterHostFromHostResource<PPB_FileRef_API> enter(host_resource); + if (enter.succeeded()) + result.Return(dispatcher(), enter.object()->GetAbsolutePath()); +} + +void PPB_FileRef_Proxy::OnMsgReadDirectoryEntries(const HostResource& file_ref, + uint32_t callback_id) { + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files( + new std::vector<ppapi::PPB_FileRef_CreateInfo>()); + linked_ptr<std::vector<PP_FileType> > file_types( + new std::vector<PP_FileType>()); + HostCallbackParams params(file_ref, callback_id); + EnterHostFromHostResourceForceCallback<PPB_FileRef_API> enter( + file_ref, callback_factory_, + &PPB_FileRef_Proxy::OnReadDirectoryEntriesCallbackCompleteInHost, + params, files, file_types); + if (enter.succeeded()) { + enter.SetResult(enter.object()->ReadDirectoryEntriesInHost( + files, file_types, enter.callback())); + } +} + +#endif // !defined(OS_NACL) + +void PPB_FileRef_Proxy::OnMsgCallbackComplete( + const HostResource& host_resource, + uint32_t callback_id, + int32_t result) { + // Forward the callback info to the plugin resource. + EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource); + if (enter.succeeded()) + static_cast<FileRef*>(enter.object())->ExecuteCallback(callback_id, result); +} + +void PPB_FileRef_Proxy::OnMsgQueryCallbackComplete( + const HostResource& host_resource, + const PP_FileInfo& info, + uint32_t callback_id, + int32_t result) { + EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource); + if (!enter.succeeded()) + return; + + if (result == PP_OK) { + result = static_cast<FileRef*>(enter.object())->SetFileInfo( + callback_id, info); + } + static_cast<FileRef*>(enter.object())->ExecuteCallback(callback_id, result); +} + +void PPB_FileRef_Proxy::OnMsgReadDirectoryEntriesCallbackComplete( + const HostResource& host_resource, + const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos, + const std::vector<PP_FileType>& file_types, + uint32_t callback_id, + int32_t result) { + CHECK_EQ(infos.size(), file_types.size()); + + EnterPluginFromHostResource<PPB_FileRef_API> enter(host_resource); + if (!enter.succeeded()) + return; + + if (result == PP_OK) { + result = + static_cast<FileRef*>(enter.object())->SetReadDirectoryEntriesOutput( + callback_id, infos, file_types); + } + static_cast<FileRef*>(enter.object())->ExecuteCallback( + callback_id, result); +} + +#if !defined(OS_NACL) +void PPB_FileRef_Proxy::OnCallbackCompleteInHost( + int32_t result, + const HostResource& host_resource, + uint32_t callback_id) { + // Execute OnMsgCallbackComplete in the plugin process. + Send(new PpapiMsg_PPBFileRef_CallbackComplete( + API_ID_PPB_FILE_REF, host_resource, callback_id, result)); +} + +void PPB_FileRef_Proxy::OnQueryCallbackCompleteInHost( + int32_t result, + const HostResource& host_resource, + linked_ptr<PP_FileInfo> info, + uint32_t callback_id) { + Send(new PpapiMsg_PPBFileRef_QueryCallbackComplete( + API_ID_PPB_FILE_REF, host_resource, *info, callback_id, result)); +} + +void PPB_FileRef_Proxy::OnReadDirectoryEntriesCallbackCompleteInHost( + int32_t result, + HostCallbackParams params, + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types) { + Send(new PpapiMsg_PPBFileRef_ReadDirectoryEntriesCallbackComplete( + API_ID_PPB_FILE_REF, params.host_resource, + *files, *file_types, params.callback_id, result)); +} + +#endif // !defined(OS_NACL) + +} // namespace proxy +} // namespace ppapi diff --git a/ppapi/proxy/ppb_file_ref_proxy.h b/ppapi/proxy/ppb_file_ref_proxy.h new file mode 100644 index 0000000..cbfadb5 --- /dev/null +++ b/ppapi/proxy/ppb_file_ref_proxy.h @@ -0,0 +1,138 @@ +// Copyright (c) 2011 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. + +#ifndef PPAPI_PROXY_PPB_FILE_REF_PROXY_H_ +#define PPAPI_PROXY_PPB_FILE_REF_PROXY_H_ + +#include <string> + +#include "base/basictypes.h" +#include "base/memory/linked_ptr.h" +#include "ppapi/c/pp_file_info.h" +#include "ppapi/c/pp_module.h" +#include "ppapi/c/pp_resource.h" +#include "ppapi/c/pp_time.h" +#include "ppapi/proxy/interface_proxy.h" +#include "ppapi/proxy/ppapi_proxy_export.h" +#include "ppapi/proxy/proxy_completion_callback_factory.h" +#include "ppapi/shared_impl/host_resource.h" +#include "ppapi/utility/completion_callback_factory.h" + +namespace ppapi { + +struct PPB_FileRef_CreateInfo; + +namespace proxy { + +class SerializedVarReturnValue; + +class PPAPI_PROXY_EXPORT PPB_FileRef_Proxy + : public NON_EXPORTED_BASE(InterfaceProxy) { + public: + explicit PPB_FileRef_Proxy(Dispatcher* dispatcher); + virtual ~PPB_FileRef_Proxy(); + + static PP_Resource CreateProxyResource(PP_Instance instance, + PP_Resource file_system, + const char* path); + static PP_Resource CreateProxyResource( + const PPB_FileRef_CreateInfo& serialized); + + // InterfaceProxy implementation. + virtual bool OnMessageReceived(const IPC::Message& msg); + + // Takes a resource in the host and converts it into a serialized file ref + // "create info" for reconstitution in the plugin. This struct contains all + // the necessary information about the file ref. + // + // Various PPAPI functions return file refs from various interfaces, so this + // function is public so anybody can send a file ref. + static void SerializeFileRef(PP_Resource file_ref, + PPB_FileRef_CreateInfo* result); + + // Creates a plugin resource from the given CreateInfo sent from the host. + // The value will be the result of calling SerializeFileRef on the host. + // This represents passing the resource ownership to the plugin. This + // function also checks the validity of the result and returns 0 on failure. + // + // Various PPAPI functions return file refs from various interfaces, so this + // function is public so anybody can receive a file ref. + static PP_Resource DeserializeFileRef( + const PPB_FileRef_CreateInfo& serialized); + + static const ApiID kApiID = API_ID_PPB_FILE_REF; + + private: + // Plugin -> host message handlers. + void OnMsgCreate(PP_Instance instance, + PP_Resource file_system, + const std::string& path, + PPB_FileRef_CreateInfo* result); + void OnMsgGetParent(const HostResource& host_resource, + PPB_FileRef_CreateInfo* result); + void OnMsgMakeDirectory(const HostResource& host_resource, + PP_Bool make_ancestors, + uint32_t callback_id); + void OnMsgTouch(const HostResource& host_resource, + PP_Time last_access, + PP_Time last_modified, + uint32_t callback_id); + void OnMsgDelete(const HostResource& host_resource, + uint32_t callback_id); + void OnMsgRename(const HostResource& file_ref, + const HostResource& new_file_ref, + uint32_t callback_id); + void OnMsgQuery(const HostResource& file_ref, + uint32_t callback_id); + void OnMsgGetAbsolutePath(const HostResource& host_resource, + SerializedVarReturnValue result); + void OnMsgReadDirectoryEntries(const HostResource& file_ref, + uint32_t callback_id); + + // Host -> Plugin message handlers. + void OnMsgCallbackComplete(const HostResource& host_resource, + uint32_t callback_id, + int32_t result); + void OnMsgQueryCallbackComplete(const HostResource& host_resource, + const PP_FileInfo& info, + uint32_t callback_id, + int32_t result); + void OnMsgReadDirectoryEntriesCallbackComplete( + const HostResource& host_resource, + const std::vector<ppapi::PPB_FileRef_CreateInfo>& infos, + const std::vector<PP_FileType>& file_types, + uint32_t callback_id, + int32_t result); + + struct HostCallbackParams { + HostCallbackParams(const HostResource& host_res, uint32_t cb_id) + : host_resource(host_res), callback_id(cb_id) { + } + HostResource host_resource; + uint32_t callback_id; + }; + + void OnCallbackCompleteInHost(int32_t result, + const HostResource& host_resource, + uint32_t callback_id); + void OnQueryCallbackCompleteInHost( + int32_t result, + const HostResource& host_resource, + linked_ptr<PP_FileInfo> info, + uint32_t callback_id); + void OnReadDirectoryEntriesCallbackCompleteInHost( + int32_t result, + HostCallbackParams params, + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types); + + ProxyCompletionCallbackFactory<PPB_FileRef_Proxy> callback_factory_; + + DISALLOW_COPY_AND_ASSIGN(PPB_FileRef_Proxy); +}; + +} // namespace proxy +} // namespace ppapi + +#endif // PPAPI_PROXY_PPB_FILE_REF_PROXY_H_ diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc index 8b7eb11..53cade1 100644 --- a/ppapi/proxy/resource_creation_proxy.cc +++ b/ppapi/proxy/resource_creation_proxy.cc @@ -11,7 +11,6 @@ #include "ppapi/proxy/ext_crx_file_system_private_resource.h" #include "ppapi/proxy/file_chooser_resource.h" #include "ppapi/proxy/file_io_resource.h" -#include "ppapi/proxy/file_ref_resource.h" #include "ppapi/proxy/file_system_resource.h" #include "ppapi/proxy/flash_drm_resource.h" #include "ppapi/proxy/flash_font_file_resource.h" @@ -27,6 +26,7 @@ #include "ppapi/proxy/ppb_audio_proxy.h" #include "ppapi/proxy/ppb_broker_proxy.h" #include "ppapi/proxy/ppb_buffer_proxy.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/proxy/ppb_flash_message_loop_proxy.h" #include "ppapi/proxy/ppb_graphics_3d_proxy.h" #include "ppapi/proxy/ppb_image_data_proxy.h" @@ -78,10 +78,15 @@ PP_Resource ResourceCreationProxy::CreateFileIO(PP_Instance instance) { return (new FileIOResource(GetConnection(), instance))->GetReference(); } +PP_Resource ResourceCreationProxy::CreateFileRef(PP_Instance instance, + PP_Resource file_system, + const char* path) { + return PPB_FileRef_Proxy::CreateProxyResource(instance, file_system, path); +} + PP_Resource ResourceCreationProxy::CreateFileRef( - PP_Instance instance, - const FileRefCreateInfo& create_info) { - return FileRefResource::CreateFileRef(GetConnection(), instance, create_info); + const PPB_FileRef_CreateInfo& create_info) { + return PPB_FileRef_Proxy::DeserializeFileRef(create_info); } PP_Resource ResourceCreationProxy::CreateFileSystem( diff --git a/ppapi/proxy/resource_creation_proxy.h b/ppapi/proxy/resource_creation_proxy.h index 2cd86d5..47b40a8 100644 --- a/ppapi/proxy/resource_creation_proxy.h +++ b/ppapi/proxy/resource_creation_proxy.h @@ -38,9 +38,11 @@ class ResourceCreationProxy : public InterfaceProxy, // ResourceCreationAPI (called in plugin). virtual PP_Resource CreateFileIO(PP_Instance instance) OVERRIDE; + virtual PP_Resource CreateFileRef(PP_Instance instance, + PP_Resource file_system, + const char* path) OVERRIDE; virtual PP_Resource CreateFileRef( - PP_Instance instance, - const FileRefCreateInfo& create_info) OVERRIDE; + const PPB_FileRef_CreateInfo& create_info) OVERRIDE; virtual PP_Resource CreateFileSystem(PP_Instance instance, PP_FileSystemType type) OVERRIDE; virtual PP_Resource CreateIsolatedFileSystem( diff --git a/ppapi/proxy/url_loader_resource.cc b/ppapi/proxy/url_loader_resource.cc index 1ff0a5e..5bbc937 100644 --- a/ppapi/proxy/url_loader_resource.cc +++ b/ppapi/proxy/url_loader_resource.cc @@ -9,8 +9,8 @@ #include "ppapi/c/pp_errors.h" #include "ppapi/c/ppb_url_loader.h" #include "ppapi/proxy/dispatch_reply_message.h" -#include "ppapi/proxy/file_ref_resource.h" #include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/proxy/url_request_info_resource.h" #include "ppapi/proxy/url_response_info_resource.h" #include "ppapi/shared_impl/ppapi_globals.h" @@ -158,14 +158,9 @@ int32_t URLLoaderResource::ReadResponseBody( int32_t rv = ValidateCallback(callback); if (rv != PP_OK) return rv; - if (!response_info_.get()) + if (!response_info_.get() || + !response_info_->data().body_as_file_ref.resource.is_null()) return PP_ERROR_FAILED; - - // Fail if we have a valid file ref. - // ReadResponseBody() is for reading to a user-provided buffer. - if (response_info_->data().body_as_file_ref.IsValid()) - return PP_ERROR_FAILED; - if (bytes_to_read <= 0 || !buffer) return PP_ERROR_BADARGUMENT; @@ -191,11 +186,8 @@ int32_t URLLoaderResource::FinishStreamingToFile( int32_t rv = ValidateCallback(callback); if (rv != PP_OK) return rv; - if (!response_info_.get()) - return PP_ERROR_FAILED; - - // Fail if we do not have a valid file ref. - if (!response_info_->data().body_as_file_ref.IsValid()) + if (!response_info_.get() || + response_info_->data().body_as_file_ref.resource.is_null()) return PP_ERROR_FAILED; // We may have already reached EOF. @@ -365,10 +357,10 @@ void URLLoaderResource::RunCallback(int32_t result) { void URLLoaderResource::SaveResponseInfo(const URLResponseInfoData& data) { // Create a proxy resource for the the file ref host resource if needed. PP_Resource body_as_file_ref = 0; - if (data.body_as_file_ref.IsValid()) { - body_as_file_ref = FileRefResource::CreateFileRef(connection(), - pp_instance(), - data.body_as_file_ref); + if (!data.body_as_file_ref.resource.is_null()) { + thunk::EnterResourceCreationNoLock enter(pp_instance()); + body_as_file_ref = + enter.functions()->CreateFileRef(data.body_as_file_ref); } response_info_ = new URLResponseInfoResource( connection(), pp_instance(), data, body_as_file_ref); @@ -397,4 +389,4 @@ size_t URLLoaderResource::FillUserBuffer() { } } // namespace proxy -} // namespace ppapi +} // namespace ppapi
\ No newline at end of file diff --git a/ppapi/proxy/url_response_info_resource.cc b/ppapi/proxy/url_response_info_resource.cc index 315b4a1..85dae9a 100644 --- a/ppapi/proxy/url_response_info_resource.cc +++ b/ppapi/proxy/url_response_info_resource.cc @@ -4,7 +4,7 @@ #include "ppapi/proxy/url_response_info_resource.h" -#include "ppapi/proxy/file_ref_resource.h" +#include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/shared_impl/var.h" #include "ppapi/thunk/enter.h" #include "ppapi/thunk/resource_creation_api.h" diff --git a/ppapi/shared_impl/file_ref_create_info.cc b/ppapi/shared_impl/file_ref_create_info.cc deleted file mode 100644 index 68c3f17..0000000 --- a/ppapi/shared_impl/file_ref_create_info.cc +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright 2013 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/shared_impl/file_ref_create_info.h" - -#include "base/logging.h" -#include "base/strings/utf_string_conversions.h" -#include "ppapi/c/pp_file_info.h" - -namespace ppapi { - -namespace { - -std::string GetNameForExternalFilePath(const base::FilePath& in_path) { - const base::FilePath::StringType& path = in_path.value(); - size_t pos = path.rfind(base::FilePath::kSeparators[0]); - CHECK(pos != base::FilePath::StringType::npos); -#if defined(OS_WIN) - return base::WideToUTF8(path.substr(pos + 1)); -#elif defined(OS_POSIX) - return path.substr(pos + 1); -#else -#error "Unsupported platform." -#endif -} - -} // namespace - -bool FileRefCreateInfo::IsValid() const { - return file_system_type != PP_FILESYSTEMTYPE_INVALID; -} - -FileRefCreateInfo -MakeExternalFileRefCreateInfo(const base::FilePath& external_path, - const std::string& display_name, - int pending_host_resource_id) { - FileRefCreateInfo info; - info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL; - if (!display_name.empty()) - info.display_name = display_name; - else - info.display_name = GetNameForExternalFilePath(external_path); - info.pending_host_resource_id = pending_host_resource_id; - return info; -} - -} // namespace ppapi diff --git a/ppapi/shared_impl/file_ref_create_info.h b/ppapi/shared_impl/file_ref_create_info.h index ae570e6..a3599f7 100644 --- a/ppapi/shared_impl/file_ref_create_info.h +++ b/ppapi/shared_impl/file_ref_create_info.h @@ -10,19 +10,12 @@ #include "base/files/file_path.h" #include "ppapi/c/pp_file_info.h" #include "ppapi/c/pp_resource.h" -#include "ppapi/shared_impl/ppapi_shared_export.h" namespace ppapi { // FileRefs are created in a number of places and they include a number of // return values. This struct encapsulates everything in one place. -struct FileRefCreateInfo { - FileRefCreateInfo() : file_system_type(PP_FILESYSTEMTYPE_INVALID), - pending_host_resource_id(0), - file_system_plugin_resource(0) { } - - PPAPI_SHARED_EXPORT bool IsValid() const; - +struct FileRef_CreateInfo { PP_FileSystemType file_system_type; std::string internal_path; std::string display_name; @@ -31,18 +24,10 @@ struct FileRefCreateInfo { int pending_host_resource_id; // Since FileRef needs to hold a FileSystem reference, we need to pass the - // resource in this CreateInfo. This struct doesn't hold any refrence on the - // file_system_plugin_resource. + // resource in this CreateInfo. PP_Resource file_system_plugin_resource; }; -// Used in the renderer when sending a FileRefCreateInfo to a plugin for a -// FileRef on an external filesystem. -PPAPI_SHARED_EXPORT FileRefCreateInfo -MakeExternalFileRefCreateInfo(const base::FilePath& external_path, - const std::string& display_name, - int pending_host_resource_id); - } // namespace ppapi #endif // PPAPI_SHARED_IMPL_FILE_REF_CREATE_INFO_H diff --git a/ppapi/shared_impl/file_ref_detailed_info.h b/ppapi/shared_impl/file_ref_detailed_info.h deleted file mode 100644 index 858effa..0000000 --- a/ppapi/shared_impl/file_ref_detailed_info.h +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright 2013 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. - -#ifndef PPAPI_SHARED_IMPL_FILE_REF_DETAILED_INFO_H -#define PPAPI_SHARED_IMPL_FILE_REF_DETAILED_INFO_H - -#include <string> - -#include "base/files/file_path.h" -#include "ppapi/c/pp_file_info.h" -#include "ppapi/c/pp_resource.h" - -namespace ppapi { - -// This structure is only used for exchanging information about FileRefs from -// the browser to the renderer. -struct FileRefDetailedInfo { - // This struct doesn't hold a ref on this resource. - PP_Resource resource; - PP_FileSystemType file_system_type; - std::string file_system_url_spec; - base::FilePath external_path; -}; - -} // namespace ppapi - -#endif // PPAPI_SHARED_IMPL_FILE_REF_DETAILED_INFO_H diff --git a/ppapi/shared_impl/ppb_file_ref_shared.cc b/ppapi/shared_impl/ppb_file_ref_shared.cc new file mode 100644 index 0000000..a47cdb8 --- /dev/null +++ b/ppapi/shared_impl/ppb_file_ref_shared.cc @@ -0,0 +1,54 @@ +// Copyright (c) 2012 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/shared_impl/ppb_file_ref_shared.h" + +#include "base/logging.h" +#include "ppapi/shared_impl/var.h" + +namespace ppapi { + +PPB_FileRef_Shared::PPB_FileRef_Shared(ResourceObjectType type, + const PPB_FileRef_CreateInfo& info) + : Resource(type, info.resource), + create_info_(info) { + if (type == OBJECT_IS_IMPL) { + // Resource's constructor assigned a PP_Resource, so we can fill out our + // host resource now. + create_info_.resource = host_resource(); + } +} + +PPB_FileRef_Shared::~PPB_FileRef_Shared() { +} + +thunk::PPB_FileRef_API* PPB_FileRef_Shared::AsPPB_FileRef_API() { + return this; +} + +PP_FileSystemType PPB_FileRef_Shared::GetFileSystemType() const { + return static_cast<PP_FileSystemType>(create_info_.file_system_type); +} + +PP_Var PPB_FileRef_Shared::GetName() const { + if (!name_var_.get()) { + name_var_ = new StringVar(create_info_.name); + } + return name_var_->GetPPVar(); +} + +PP_Var PPB_FileRef_Shared::GetPath() const { + if (create_info_.file_system_type == PP_FILESYSTEMTYPE_EXTERNAL) + return PP_MakeUndefined(); + if (!path_var_.get()) { + path_var_ = new StringVar(create_info_.path); + } + return path_var_->GetPPVar(); +} + +const PPB_FileRef_CreateInfo& PPB_FileRef_Shared::GetCreateInfo() const { + return create_info_; +} + +} // namespace ppapi diff --git a/ppapi/shared_impl/ppb_file_ref_shared.h b/ppapi/shared_impl/ppb_file_ref_shared.h new file mode 100644 index 0000000..5025eb3 --- /dev/null +++ b/ppapi/shared_impl/ppb_file_ref_shared.h @@ -0,0 +1,70 @@ +// Copyright (c) 2012 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. + +#ifndef PPAPI_SHARED_IMPL_PPB_FILE_REF_SHARED_H_ +#define PPAPI_SHARED_IMPL_PPB_FILE_REF_SHARED_H_ + +#include <string> + +#include "base/compiler_specific.h" +#include "ppapi/shared_impl/resource.h" +#include "ppapi/thunk/ppb_file_ref_api.h" + +namespace ppapi { + +class StringVar; + +// FileRefs are created in a number of places and they include a number of +// return values. This struct encapsulates everything in one place. +struct PPB_FileRef_CreateInfo { + PPB_FileRef_CreateInfo() + : file_system_type(PP_FILESYSTEMTYPE_EXTERNAL), + file_system_plugin_resource(0) {} + + ppapi::HostResource resource; + int file_system_type; // One of PP_FileSystemType values. + std::string path; + std::string name; + + // Since FileRef needs to hold a FileSystem reference, we need to pass the + // resource in this CreateInfo. Note that this is a plugin resource as + // FileSystem is already in new design. + PP_Resource file_system_plugin_resource; +}; + +// This class provides the shared implementation of a FileRef. The functions +// that actually "do stuff" like Touch and MakeDirectory are implemented +// differently for the proxied and non-proxied derived classes. +class PPAPI_SHARED_EXPORT PPB_FileRef_Shared + : public Resource, + public thunk::PPB_FileRef_API { + public: + PPB_FileRef_Shared(ResourceObjectType type, + const PPB_FileRef_CreateInfo& info); + virtual ~PPB_FileRef_Shared(); + + // Resource overrides. + virtual thunk::PPB_FileRef_API* AsPPB_FileRef_API() OVERRIDE; + + // PPB_FileRef_API implementation (partial). + virtual PP_FileSystemType GetFileSystemType() const OVERRIDE; + virtual PP_Var GetName() const OVERRIDE; + virtual PP_Var GetPath() const OVERRIDE; + virtual const PPB_FileRef_CreateInfo& GetCreateInfo() const OVERRIDE; + virtual PP_Var GetAbsolutePath() = 0; + + private: + PPB_FileRef_CreateInfo create_info_; + + // Lazily initialized vars created from the create_info_. This is so we can + // return the identical string object every time they're requested. + mutable scoped_refptr<StringVar> name_var_; + mutable scoped_refptr<StringVar> path_var_; + + DISALLOW_IMPLICIT_CONSTRUCTORS(PPB_FileRef_Shared); +}; + +} // namespace ppapi + +#endif // PPAPI_SHARED_IMPL_PPB_FILE_REF_SHARED_H_ diff --git a/ppapi/shared_impl/url_request_info_data.cc b/ppapi/shared_impl/url_request_info_data.cc index 15b2787..8bb02a4 100644 --- a/ppapi/shared_impl/url_request_info_data.cc +++ b/ppapi/shared_impl/url_request_info_data.cc @@ -17,7 +17,6 @@ const int32_t kDefaultPrefetchBufferLowerThreshold = 50 * 1000 * 1000; URLRequestInfoData::BodyItem::BodyItem() : is_file(false), - file_ref_pp_resource(0), start_offset(0), number_of_bytes(-1), expected_last_modified_time(0.0) { @@ -26,7 +25,6 @@ URLRequestInfoData::BodyItem::BodyItem() URLRequestInfoData::BodyItem::BodyItem(const std::string& data) : is_file(false), data(data), - file_ref_pp_resource(0), start_offset(0), number_of_bytes(-1), expected_last_modified_time(0.0) { @@ -38,8 +36,8 @@ URLRequestInfoData::BodyItem::BodyItem( int64_t number_of_bytes, PP_Time expected_last_modified_time) : is_file(true), - file_ref_resource(file_ref), - file_ref_pp_resource(file_ref->pp_resource()), + file_ref(file_ref), + file_ref_host_resource(file_ref->host_resource()), start_offset(start_offset), number_of_bytes(number_of_bytes), expected_last_modified_time(expected_last_modified_time) { diff --git a/ppapi/shared_impl/url_request_info_data.h b/ppapi/shared_impl/url_request_info_data.h index d0acf4b..501251a 100644 --- a/ppapi/shared_impl/url_request_info_data.h +++ b/ppapi/shared_impl/url_request_info_data.h @@ -9,12 +9,10 @@ #include <vector> #include "base/memory/ref_counted.h" -#include "ppapi/c/pp_resource.h" #include "ppapi/c/pp_stdint.h" #include "ppapi/c/pp_time.h" -#include "ppapi/shared_impl/ppapi_globals.h" +#include "ppapi/shared_impl/host_resource.h" #include "ppapi/shared_impl/ppapi_shared_export.h" -#include "ppapi/shared_impl/resource_tracker.h" namespace ppapi { @@ -34,12 +32,19 @@ struct PPAPI_SHARED_EXPORT URLRequestInfoData { std::string data; - // Only set on the plugin-side, for refcounting purposes. Only valid when - // |is_file| is set. - scoped_refptr<Resource> file_ref_resource; - // This struct holds no ref to this resource. Only valid when |is_file| is - // set. - PP_Resource file_ref_pp_resource; + // Is is_file is set, these variables are set. Note that the resource + // may still be NULL in some cases, such as deserialization errors. + // + // This is a bit tricky. In the plugin side of the proxy, both the file ref + // and the file_ref_host_resource will be set and valid. The scoped_refptr + // ensures that the resource is alive for as long as the BodyItem is. + // + // When we deserialize this in the renderer, only the + // file_ref_host_resource's are serialized over IPC. The file_refs won't be + // valid until the host resources are converted to Resource pointers in the + // PPB_URLRequestInfo_Impl. + scoped_refptr<Resource> file_ref; + HostResource file_ref_host_resource; int64_t start_offset; int64_t number_of_bytes; diff --git a/ppapi/shared_impl/url_response_info_data.h b/ppapi/shared_impl/url_response_info_data.h index c6f7dbd..a40ca50 100644 --- a/ppapi/shared_impl/url_response_info_data.h +++ b/ppapi/shared_impl/url_response_info_data.h @@ -8,7 +8,7 @@ #include <string> #include "ppapi/c/pp_stdint.h" -#include "ppapi/shared_impl/file_ref_create_info.h" +#include "ppapi/shared_impl/ppb_file_ref_shared.h" #include "ppapi/shared_impl/ppapi_shared_export.h" namespace ppapi { @@ -23,8 +23,8 @@ struct PPAPI_SHARED_EXPORT URLResponseInfoData { std::string status_text; std::string redirect_url; - // Valid when streaming to a file. - FileRefCreateInfo body_as_file_ref; + // Nonzero when streaming to a file. + PPB_FileRef_CreateInfo body_as_file_ref; }; } // namespace ppapi diff --git a/ppapi/thunk/interfaces_ppb_private.h b/ppapi/thunk/interfaces_ppb_private.h index 391904d3..3e0289c 100644 --- a/ppapi/thunk/interfaces_ppb_private.h +++ b/ppapi/thunk/interfaces_ppb_private.h @@ -33,7 +33,7 @@ PROXIED_IFACE(NoAPIName, PPB_FILECHOOSER_TRUSTED_INTERFACE_0_5, PPB_FileChooserTrusted_0_5) PROXIED_IFACE(NoAPIName, PPB_FILECHOOSER_TRUSTED_INTERFACE_0_6, PPB_FileChooserTrusted_0_6) -PROXIED_IFACE(NoAPIName, PPB_FILEREFPRIVATE_INTERFACE_0_1, +PROXIED_IFACE(PPB_FileRef, PPB_FILEREFPRIVATE_INTERFACE_0_1, PPB_FileRefPrivate_0_1) // TODO(xhwang): Move PPB_Flash_DeviceID back to interfaces_ppb_private_flash.h. PROXIED_IFACE(NoAPIName, PPB_FLASH_DEVICEID_INTERFACE_1_0, diff --git a/ppapi/thunk/interfaces_ppb_public_stable.h b/ppapi/thunk/interfaces_ppb_public_stable.h index eac850e..b0918a3 100644 --- a/ppapi/thunk/interfaces_ppb_public_stable.h +++ b/ppapi/thunk/interfaces_ppb_public_stable.h @@ -19,6 +19,7 @@ // that exist in the webkit/plugins/ppapi/*_impl.h, but not in the proxy. PROXIED_API(PPB_Audio) PROXIED_API(PPB_Core) +PROXIED_API(PPB_FileRef) PROXIED_API(PPB_Graphics3D) PROXIED_API(PPB_ImageData) PROXIED_API(PPB_Instance) @@ -45,8 +46,8 @@ UNPROXIED_API(PPB_AudioConfig) // interface string. // Note: Core is special and is registered manually. PROXIED_IFACE(PPB_Audio, PPB_AUDIO_INTERFACE_1_0, PPB_Audio_1_0) -PROXIED_IFACE(NoAPIName, PPB_FILEREF_INTERFACE_1_0, PPB_FileRef_1_0) -PROXIED_IFACE(NoAPIName, PPB_FILEREF_INTERFACE_1_1, PPB_FileRef_1_1) +PROXIED_IFACE(PPB_FileRef, PPB_FILEREF_INTERFACE_1_0, PPB_FileRef_1_0) +PROXIED_IFACE(PPB_FileRef, PPB_FILEREF_INTERFACE_1_1, PPB_FileRef_1_1) PROXIED_IFACE(NoAPIName, PPB_FILESYSTEM_INTERFACE_1_0, PPB_FileSystem_1_0) PROXIED_IFACE(PPB_Graphics3D, PPB_GRAPHICS_3D_INTERFACE_1_0, PPB_Graphics3D_1_0) PROXIED_IFACE(PPB_ImageData, PPB_IMAGEDATA_INTERFACE_1_0, PPB_ImageData_1_0) diff --git a/ppapi/thunk/ppb_file_ref_api.h b/ppapi/thunk/ppb_file_ref_api.h index b473ae2..ba92b63 100644 --- a/ppapi/thunk/ppb_file_ref_api.h +++ b/ppapi/thunk/ppb_file_ref_api.h @@ -10,12 +10,11 @@ #include "base/memory/linked_ptr.h" #include "base/memory/ref_counted.h" #include "ppapi/c/ppb_file_ref.h" -#include "ppapi/shared_impl/file_ref_create_info.h" #include "ppapi/thunk/ppapi_thunk_export.h" namespace ppapi { -struct FileRefCreateInfo; +struct PPB_FileRef_CreateInfo; class TrackedCallback; namespace thunk { @@ -41,10 +40,25 @@ class PPAPI_THUNK_EXPORT PPB_FileRef_API { virtual int32_t ReadDirectoryEntries( const PP_ArrayOutput& output, scoped_refptr<TrackedCallback> callback) = 0; + // We define variants of Query and ReadDirectoryEntries because + // 1. we need to take linked_ptr instead of raw pointers to avoid + // use-after-free, and 2. we don't use PP_ArrayOutput for the + // communication between renderers and the browser in + // ReadDirectoryEntries. The *InHost functions must not be called in + // plugins, and Query and ReadDirectoryEntries must not be called in + // renderers. + // TODO(hamaji): These functions must be removed when we move + // FileRef to the new resource design. http://crbug.com/225441 + virtual int32_t QueryInHost(linked_ptr<PP_FileInfo> info, + scoped_refptr<TrackedCallback> callback) = 0; + virtual int32_t ReadDirectoryEntriesInHost( + linked_ptr<std::vector<ppapi::PPB_FileRef_CreateInfo> > files, + linked_ptr<std::vector<PP_FileType> > file_types, + scoped_refptr<TrackedCallback> callback) = 0; // Internal function for use in proxying. Returns the internal CreateInfo // (the contained resource does not carry a ref on behalf of the caller). - virtual const FileRefCreateInfo& GetCreateInfo() const = 0; + virtual const PPB_FileRef_CreateInfo& GetCreateInfo() const = 0; // Private API virtual PP_Var GetAbsolutePath() = 0; diff --git a/ppapi/thunk/ppb_file_ref_thunk.cc b/ppapi/thunk/ppb_file_ref_thunk.cc index 8910faf..beb0e41 100644 --- a/ppapi/thunk/ppb_file_ref_thunk.cc +++ b/ppapi/thunk/ppb_file_ref_thunk.cc @@ -7,7 +7,6 @@ #include "ppapi/c/pp_completion_callback.h" #include "ppapi/c/pp_errors.h" #include "ppapi/c/private/ppb_file_ref_private.h" -#include "ppapi/shared_impl/file_ref_create_info.h" #include "ppapi/shared_impl/proxy_lock.h" #include "ppapi/shared_impl/tracked_callback.h" #include "ppapi/thunk/enter.h" @@ -33,12 +32,7 @@ PP_Resource Create(PP_Resource file_system, const char* path) { EnterResourceCreationNoLock enter(instance); if (enter.failed()) return 0; - FileRefCreateInfo info; - info.file_system_type = enter_file_system.object()->GetType(); - info.internal_path = std::string(path); - info.pending_host_resource_id = 0; - info.file_system_plugin_resource = file_system; - return enter.functions()->CreateFileRef(instance, info); + return enter.functions()->CreateFileRef(instance, file_system, path); } PP_Bool IsFileRef(PP_Resource resource) { diff --git a/ppapi/thunk/resource_creation_api.h b/ppapi/thunk/resource_creation_api.h index bab3bb9..082f1cc 100644 --- a/ppapi/thunk/resource_creation_api.h +++ b/ppapi/thunk/resource_creation_api.h @@ -33,7 +33,7 @@ struct PP_Size; namespace ppapi { -struct FileRefCreateInfo; +struct PPB_FileRef_CreateInfo; struct URLRequestInfoData; struct URLResponseInfoData; @@ -49,9 +49,15 @@ class ResourceCreationAPI { virtual ~ResourceCreationAPI() {} virtual PP_Resource CreateFileIO(PP_Instance instance) = 0; + virtual PP_Resource CreateFileRef(PP_Instance instance, + PP_Resource file_system, + const char* path) = 0; + // Like the above version but takes a serialized file ref. The resource + // in the serialized file ref is passed into this, which takes ownership of + // the reference. In the proxy, the return value will be a plugin resource. + // In the impl, the return value will be the same resource ID. virtual PP_Resource CreateFileRef( - PP_Instance instance, - const FileRefCreateInfo& serialized) = 0; + const PPB_FileRef_CreateInfo& serialized) = 0; virtual PP_Resource CreateFileSystem(PP_Instance instance, PP_FileSystemType type) = 0; virtual PP_Resource CreateIsolatedFileSystem(PP_Instance instance, |