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* render_process_host =
       RenderProcessHost::FromID(render_process_id);
   if (!render_process_host)
     return NULL;
   StoragePartition* storage_partition =
       render_process_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 117 matching lines @@
   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));
   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()) {
+    reply_context.params.set_result(PP_ERROR_FAILED);
+    host()->SendReply(reply_context,
+                      PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply());
+    return;
+  }
+
+  root_url_ = GURL(fileapi::GetIsolatedFileSystemRootURIString(

[teravest, 2013/11/12 18:04:53]

Should we do anything if root_url_.is_valid() is false? Seems like we'd want to
return some kind of error here.

[nhiroki, 2013/11/14 11:34:39]

Done.

+      browser_ppapi_host_->GetDocumentURLForInstance(pp_instance()),
+      fsid, ppapi::IsolatedFileSystemTypeToRootName(type)));
+
+  switch (type) {
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_INVALID:

[teravest, 2013/11/12 18:04:53]

Should this just be the default case for the switch statement?

[nhiroki, 2013/11/14 11:34:39]

Done.

+      NOTREACHED();
+      reply_context.params.set_result(PP_ERROR_BADARGUMENT);
+      break;
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_CRX:
+      opened_ = true;
+      reply_context.params.set_result(PP_OK);
+      break;
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_PLUGINPRIVATE:
+      OpenPluginPrivateFileSystem(reply_context, fsid, fs_context);
+      return;
+  }
+  host()->SendReply(reply_context,
+                    PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply());
+}
+
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystem(
+    ppapi::host::ReplyMessageContext reply_context,
+    const std::string& fsid,
+    scoped_refptr<fileapi::FileSystemContext> fs_context) {
+  GURL origin = browser_ppapi_host_->GetDocumentURLForInstance(

[teravest, 2013/11/12 18:04:53]

Should we do a validity check on origin here?

[nhiroki, 2013/11/14 11:34:39]

Done.

+      pp_instance()).GetOrigin();
+
+  const std::string plugin_id = GeneratePluginId();
+  if (plugin_id.empty()) {
+    fileapi::IsolatedContext::GetInstance()->RevokeFileSystem(fsid);
+    reply_context.params.set_result(PP_ERROR_BADARGUMENT);
+    host()->SendReply(reply_context,
+                      PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply());
+    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));
+}
+
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystemComplete(
+    ppapi::host::ReplyMessageContext reply_context,
+    base::PlatformFileError error) {
+  int32 pp_error = ppapi::PlatformFileErrorToPepperError(error);
+  if (pp_error == PP_OK)
+    opened_ = true;
+  reply_context.params.set_result(pp_error);
+  host()->SendReply(
+      reply_context,
+      PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply());
+}
+
 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)) {
     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;
 }
 
+std::string PepperFileSystemBrowserHost::GeneratePluginId() {
+  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 "._-".

[teravest, 2013/11/12 18:04:53]

This is stricter than what mime types require, right? I think this is probably
ok, though I guess plugins will just silently fail if they have semicolons or
other things in their content-type?

[nhiroki, 2013/11/14 11:34:39]

That's right. MIME type requires at least one slash should be included, but file
path cannot accept it.

In addition, file path cannot accept ';', ':', '*'.... I guess MIME types for
pepper plugins might not contain those characters, so for now I adopt the
stricter way. If these characters should be acceptable, we need to consider ways
to escape them in consideration of file path limitation (ex. length).
Added LOG to show generation error when it contains unacceptable characters.

+  for (std::string::const_iterator it = output.begin();
+       it != output.end(); ++it) {
+    if (!IsAsciiAlpha(*it) && !IsAsciiDigit(*it) &&
+        *it != '.' && *it != '_' && *it != '-') {
+      return std::string();
+    }
+  }
+  return output;
+}
+
 }  // namespace content