PPAPI: Add PluginPrivateFileSystem

content/browser/renderer_host/pepper/pepper_file_system_browser_host.cc

 // 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 "content/browser/renderer_host/pepper/pepper_file_system_browser_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.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/shared_impl/file_type_conversion.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/common/fileapi/file_system_util.h"
@@ skipping 68 matching lines @@
 int32_t PepperFileSystemBrowserHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     ppapi::host::HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperFileSystemBrowserHost, msg)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(
         PpapiHostMsg_FileSystem_Open,
         OnHostMsgOpen)
     PPAPI_DISPATCH_HOST_RESOURCE_CALL(
         PpapiHostMsg_FileSystem_InitIsolatedFileSystem,
         OnHostMsgInitIsolatedFileSystem)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
+        PpapiHostMsg_FileSystem_OpenPluginPrivateFileSystem,
+        OnHostMsgOpenPluginPrivateFileSystem)
   IPC_END_MESSAGE_MAP()
   return PP_ERROR_FAILED;
 }
 
 bool PepperFileSystemBrowserHost::IsFileSystemHost() {
   return true;
 }
 
 int32_t PepperFileSystemBrowserHost::OnHostMsgOpen(
     ppapi::host::HostMessageContext* context,
@@ skipping 63 matching lines @@
     scoped_refptr<fileapi::FileSystemContext> fs_context) {
   fs_context_ = fs_context;
   if (fs_context.get())
     reply_context.params.set_result(PP_OK);
   else
     reply_context.params.set_result(PP_ERROR_FAILED);
   host()->SendReply(reply_context,
                     PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply());
 }
 
+void PepperFileSystemBrowserHost::GotFileSystemContextForPluginPrivate(
+    ppapi::host::ReplyMessageContext reply_context,
+    scoped_refptr<fileapi::FileSystemContext> fs_context) {
+  if (!fs_context.get()) {
+    OpenFileSystemComplete(
+        reply_context, GURL(), std::string(), base::PLATFORM_FILE_ERROR_FAILED);
+    return;
+  }
+  fs_context_ = fs_context;
+
+  GURL origin = browser_ppapi_host_->GetDocumentURLForInstance(
+      pp_instance()).GetOrigin();
+
+  // TODO(nhiroki): Generate a real plugin_id from the plugin's MIME type.
+  std::string dummy_plugin_id = "plugin_id";
+  fs_context->OpenPluginPrivateFileSystem(
+      origin, fileapi::kFileSystemTypePluginPrivate, dummy_plugin_id,
+      fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+      base::Bind(
+          &PepperFileSystemBrowserHost::OpenPluginPrivateFileSystemComplete,
+          weak_factory_.GetWeakPtr(), reply_context));
+}
+
 void PepperFileSystemBrowserHost::OpenFileSystemComplete(
     ppapi::host::ReplyMessageContext reply_context,
     const GURL& root,
     const std::string& /* unused */,
     base::PlatformFileError error) {
   int32 pp_error = ppapi::PlatformFileErrorToPepperError(error);
   if (pp_error == PP_OK) {
     opened_ = true;
     root_url_ = root;
   }
   reply_context.params.set_result(pp_error);
   host()->SendReply(reply_context, PpapiPluginMsg_FileSystem_OpenReply());
 }
 
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystemComplete(
+    ppapi::host::ReplyMessageContext reply_context,
+    const GURL& root,
+    const std::string& fsid,
+    base::PlatformFileError error) {
+  int32 pp_error = ppapi::PlatformFileErrorToPepperError(error);
+  if (pp_error != PP_OK) {
+    reply_context.params.set_result(pp_error);
+    host()->SendReply(
+        reply_context,
+        PpapiPluginMsg_FileSystem_OpenPluginPrivateFileSystemReply(
+            std::string()));
+    return;
+  }
+
+  int render_process_id = 0;
+  int unused;
+  if (!browser_ppapi_host_->GetRenderViewIDsForInstance(pp_instance(),
+                                                        &render_process_id,
+                                                        &unused)) {
+    reply_context.params.set_result(PP_ERROR_FAILED);
+    host()->SendReply(
+        reply_context,
+        PpapiPluginMsg_FileSystem_OpenPluginPrivateFileSystemReply(
+            std::string()));
+    return;
+  }
+
+  opened_ = true;
+  root_url_ = root;
+
+  content::ChildProcessSecurityPolicy* policy =
+      content::ChildProcessSecurityPolicy::GetInstance();
+  policy->GrantCreateReadWriteFileSystem(render_process_id, fsid);
+
+  reply_context.params.set_result(PP_OK);
+  host()->SendReply(
+      reply_context,
+      PpapiPluginMsg_FileSystem_OpenPluginPrivateFileSystemReply(fsid));
+}
+
 int32_t PepperFileSystemBrowserHost::OnHostMsgInitIsolatedFileSystem(
     ppapi::host::HostMessageContext* context,
     const std::string& fsid) {
   // Do not allow multiple opens.
   if (called_open_)
     return PP_ERROR_INPROGRESS;
   called_open_ = true;
   // Do a sanity check.
   if (!LooksLikeAGuid(fsid))
     return PP_ERROR_BADARGUMENT;
@@ skipping 13 matching lines @@
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GetFileSystemContextFromRenderId, render_process_id),
       base::Bind(&PepperFileSystemBrowserHost::GotIsolatedFileSystemContext,
                  weak_factory_.GetWeakPtr(),
                  context->MakeReplyMessageContext()));
   return PP_OK_COMPLETIONPENDING;
 }
 
+int32_t PepperFileSystemBrowserHost::OnHostMsgOpenPluginPrivateFileSystem(
+    ppapi::host::HostMessageContext* context) {
+  // Do not allow multiple opens.
+  if (called_open_)
+    return PP_ERROR_INPROGRESS;
+  called_open_ = true;
+
+  int render_process_id = 0;
+  int unused;
+  if (!browser_ppapi_host_->GetRenderViewIDsForInstance(pp_instance(),
+                                                        &render_process_id,
+                                                        &unused)) {
+    return PP_ERROR_FAILED;
+  }
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&GetFileSystemContextFromRenderId, render_process_id),
+      base::Bind(
+          &PepperFileSystemBrowserHost::GotFileSystemContextForPluginPrivate,
+          weak_factory_.GetWeakPtr(), context->MakeReplyMessageContext()));
+  return PP_OK_COMPLETIONPENDING;
+}
+
 }  // namespace content