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/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
+#include "content/public/common/pepper_plugin_info.h"
+#include "net/base/mime_util.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_system_util.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/browser/fileapi/isolated_context.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace content {
 
 namespace {
 
 scoped_refptr<fileapi::FileSystemContext>
 GetFileSystemContextFromRenderId(int render_process_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RenderProcessHost* host = RenderProcessHost::FromID(render_process_id);
   if (!host)
     return NULL;
   StoragePartition* storage_partition = host->GetStoragePartition();
   if (!storage_partition)
     return NULL;
   return storage_partition->GetFileSystemContext();
 }
 
-// TODO(nhiroki): Move this function somewhere else to be shared.
-std::string IsolatedFileSystemTypeToRootName(
-    PP_IsolatedFileSystemType_Private type) {
-  switch (type) {
-    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_INVALID:
-      break;
-    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_CRX:
-      return "crxfs";
-  }
-  NOTREACHED() << type;
-  return std::string();
-}
-
 }  // namespace
 
 PepperFileSystemBrowserHost::PepperFileSystemBrowserHost(BrowserPpapiHost* host,
                                                          PP_Instance instance,
                                                          PP_Resource resource,
                                                          PP_FileSystemType type)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       browser_ppapi_host_(host),
       type_(type),
       opened_(false),
@@ skipping 62 matching lines @@
   if (file_system_type == fileapi::kFileSystemTypeUnknown)
     return PP_ERROR_FAILED;
 
   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::GotFileSystemContext,
                  weak_factory_.GetWeakPtr(),
                  context->MakeReplyMessageContext(),
                  file_system_type));
   return PP_OK_COMPLETIONPENDING;
 }
@@ skipping 20 matching lines @@
   if (!fs_context.get()) {
     OpenFileSystemComplete(
         reply_context, GURL(), std::string(), base::PLATFORM_FILE_ERROR_FAILED);
     return;
   }
   GURL origin = browser_ppapi_host_->GetDocumentURLForInstance(
       pp_instance()).GetOrigin();
   fs_context->OpenFileSystem(origin, file_system_type,
       fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       base::Bind(&PepperFileSystemBrowserHost::OpenFileSystemComplete,
-                 weak_factory_.GetWeakPtr(),
-                 reply_context));
+                 weak_factory_.GetWeakPtr(), reply_context));
   fs_context_ = fs_context;
 }
 
-void PepperFileSystemBrowserHost::GotIsolatedFileSystemContext(
-    ppapi::host::ReplyMessageContext reply_context,
-    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::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::GotIsolatedFileSystemContext(
+    ppapi::host::ReplyMessageContext reply_context,
+    const std::string& fsid,
+    PP_IsolatedFileSystemType_Private type,
+    scoped_refptr<fileapi::FileSystemContext> fs_context) {
+  fs_context_ = fs_context;
+  if (!fs_context.get()) {
+    SendReplyForIsolatedFileSystem(reply_context, fsid, PP_ERROR_FAILED);
+    return;
+  }
+
+  root_url_ = GURL(fileapi::GetIsolatedFileSystemRootURIString(
+      browser_ppapi_host_->GetDocumentURLForInstance(pp_instance()).GetOrigin(),
+      fsid, ppapi::IsolatedFileSystemTypeToRootName(type)));
+  if (!root_url_.is_valid()) {
+    SendReplyForIsolatedFileSystem(reply_context, fsid, PP_ERROR_FAILED);
+    return;
+  }
+
+  switch (type) {
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_CRX:
+      opened_ = true;
+      SendReplyForIsolatedFileSystem(reply_context, fsid, PP_OK);
+      return;
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_PLUGINPRIVATE:
+      OpenPluginPrivateFileSystem(reply_context, fsid, fs_context);
+      return;
+    default:
+      NOTREACHED();
+      SendReplyForIsolatedFileSystem(reply_context, fsid, PP_ERROR_BADARGUMENT);
+      return;
+  }
+}
+
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystem(
+    ppapi::host::ReplyMessageContext reply_context,
+    const std::string& fsid,
+    scoped_refptr<fileapi::FileSystemContext> fs_context) {
+  GURL origin = browser_ppapi_host_->GetDocumentURLForInstance(
+      pp_instance()).GetOrigin();
+  if (!origin.is_valid()) {
+    SendReplyForIsolatedFileSystem(reply_context, fsid, PP_ERROR_FAILED);
+    return;
+  }
+
+  const std::string& plugin_id = GeneratePluginId();
+  if (plugin_id.empty()) {
+    SendReplyForIsolatedFileSystem(reply_context, fsid, PP_ERROR_BADARGUMENT);
+    return;
+  }
+
+  fs_context->OpenPluginPrivateFileSystem(
+      origin, fileapi::kFileSystemTypePluginPrivate, fsid, plugin_id,
+      fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+      base::Bind(
+          &PepperFileSystemBrowserHost::OpenPluginPrivateFileSystemComplete,
+          weak_factory_.GetWeakPtr(), reply_context, fsid));
+}
+
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystemComplete(
+    ppapi::host::ReplyMessageContext reply_context,
+    const std::string& fsid,
+    base::PlatformFileError error) {
+  int32 pp_error = ppapi::PlatformFileErrorToPepperError(error);
+  if (pp_error == PP_OK)
+    opened_ = true;
+  SendReplyForIsolatedFileSystem(reply_context, fsid, pp_error);
+}
+
 int32_t PepperFileSystemBrowserHost::OnHostMsgInitIsolatedFileSystem(
     ppapi::host::HostMessageContext* context,
     const std::string& fsid,
     PP_IsolatedFileSystemType_Private type) {
   // Do not allow multiple opens.
   if (called_open_)
     return PP_ERROR_INPROGRESS;
   called_open_ = true;
 
   // Do a sanity check.
   if (!fileapi::ValidateIsolatedFileSystemId(fsid))
     return PP_ERROR_BADARGUMENT;
 
-  const GURL& url =
-      browser_ppapi_host_->GetDocumentURLForInstance(pp_instance());
-  const std::string root_name = IsolatedFileSystemTypeToRootName(type);
-  if (root_name.empty())
-    return PP_ERROR_BADARGUMENT;
-
-  root_url_ = GURL(fileapi::GetIsolatedFileSystemRootURIString(
-      url.GetOrigin(), fsid, root_name));
-  opened_ = true;
-
   int render_process_id = 0;
   int unused;
   if (!browser_ppapi_host_->GetRenderViewIDsForInstance(pp_instance(),
                                                         &render_process_id,
                                                         &unused)) {
+    fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(fsid);
     return PP_ERROR_FAILED;
   }
+
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GetFileSystemContextFromRenderId, render_process_id),
       base::Bind(&PepperFileSystemBrowserHost::GotIsolatedFileSystemContext,
                  weak_factory_.GetWeakPtr(),
-                 context->MakeReplyMessageContext()));
+                 context->MakeReplyMessageContext(), fsid, type));
   return PP_OK_COMPLETIONPENDING;
 }
 
+void PepperFileSystemBrowserHost::SendReplyForIsolatedFileSystem(
+    ppapi::host::ReplyMessageContext reply_context,
+    const std::string& fsid,
+    int32_t error) {
+  if (error != PP_OK)
+    fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(fsid);
+  reply_context.params.set_result(error);
+  host()->SendReply(reply_context,
+                    PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply());
+}
+
+std::string PepperFileSystemBrowserHost::GeneratePluginId() const {
+  // TODO(nhiroki): This function is very specialized for specific plugins (MIME
+  // types).  If we bring this API to stable, we might have to make it more
+  // general.
+
+  base::FilePath plugin_path = browser_ppapi_host_->GetPluginPath();
+  PepperPluginInfo* info =
+      PluginService::GetInstance()->GetRegisteredPpapiPluginInfo(plugin_path);
+  if (!info || info->mime_types.empty())
+    return std::string();
+
+  // Use the first element in |info->mime_types| even if several elements exist.
+  std::string output = info->mime_types[0].mime_type;
+  if (!net::IsMimeType(output))
+    return std::string();
+
+  // Replace a slash used for type/subtype separator with an underscore.
+  // NOTE: This assumes there is only one slash in the MIME type.
+  ReplaceFirstSubstringAfterOffset(&output, 0, "/", "_");
+
+  // Verify |output| contains only alphabets, digits, or "._-".
+  for (std::string::const_iterator it = output.begin();

[Tom Sepez, 2013/11/18 19:12:29]

What if the string is entirely dots, eg. "." or ".."? You probably ought to
check that it starts with an alpha.

[nhiroki, 2013/11/19 12:15:59]

These cases would be covered by IsMimeType(). It makes sure the given type
starts with "legal_top_level_types" (ex. "application/", "image/") defined in
"net/base/mime_util.cc".

[Tom Sepez, 2013/11/19 18:20:39]

feels frail if this changes down the road, but OK.

+       it != output.end(); ++it) {
+    if (!IsAsciiAlpha(*it) && !IsAsciiDigit(*it) &&
+        *it != '.' && *it != '_' && *it != '-') {
+      LOG(WARNING) << "Failed to generate a plugin id.";
+      return std::string();
+    }
+  }
+  return output;
+}
+
 }  // namespace content