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;
   }
+
+  reply_context_ = context->MakeReplyMessageContext();

[dmichael (off chromium), 2013/11/14 18:09:31]

Did you change this for any particular reason? Passing it along with the
callback below is more idiomatic. This probably works fine here, but the reply
context is unique per message. If you have to handle more than 1 message, each
has to have its own ReplyMessageContext. Since you should be handling only 1
message, I think it works okay, but I think it would be better to leave it the
way it was.

[nhiroki, 2013/11/15 12:24:01]

I see. That was just clean-up purpose. Reverted them.

   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;
 }
 
 void PepperFileSystemBrowserHost::OpenExistingWithContext(
     const base::Closure& callback,
     scoped_refptr<fileapi::FileSystemContext> fs_context) {
   if (fs_context.get()) {
     opened_ = true;
   } else {
     // If there is no file system context, we log a warning and continue with an
     // invalid resource (which will produce errors when used), since we have no
     // way to communicate the error to the caller.
     LOG(WARNING) << "Could not retrieve file system context.";
   }
   fs_context_ = fs_context;
   callback.Run();
 }
 
 void PepperFileSystemBrowserHost::GotFileSystemContext(
-    ppapi::host::ReplyMessageContext reply_context,
     fileapi::FileSystemType file_system_type,
     scoped_refptr<fileapi::FileSystemContext> fs_context) {
   if (!fs_context.get()) {
     OpenFileSystemComplete(
-        reply_context, GURL(), std::string(), base::PLATFORM_FILE_ERROR_FAILED);
+        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()));
   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());
+  reply_context_.params.set_result(pp_error);
+  host()->SendReply(reply_context_, PpapiPluginMsg_FileSystem_OpenReply());
+}
+
+void PepperFileSystemBrowserHost::GotIsolatedFileSystemContext(
+    const std::string& fsid,
+    PP_IsolatedFileSystemType_Private type,
+    scoped_refptr<fileapi::FileSystemContext> fs_context) {
+  fs_context_ = fs_context;
+  if (!fs_context.get()) {
+    SendReplyForIsolatedFileSystem(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(fsid, PP_ERROR_FAILED);
+    return;
+  }
+
+  switch (type) {
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_CRX:
+      opened_ = true;
+      SendReplyForIsolatedFileSystem(fsid, PP_OK);
+      return;
+    case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_PLUGINPRIVATE:
+      OpenPluginPrivateFileSystem(fsid, fs_context);
+      return;
+    default:
+      NOTREACHED();
+      SendReplyForIsolatedFileSystem(fsid, PP_ERROR_BADARGUMENT);
+      return;
+  }
+}
+
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystem(
+    const std::string& fsid,
+    scoped_refptr<fileapi::FileSystemContext> fs_context) {
+  GURL origin = browser_ppapi_host_->GetDocumentURLForInstance(
+      pp_instance()).GetOrigin();
+  if (!origin.is_valid()) {
+    SendReplyForIsolatedFileSystem(fsid, PP_ERROR_FAILED);
+    return;
+  }
+
+  const std::string plugin_id = GeneratePluginId();
+  if (plugin_id.empty()) {
+    SendReplyForIsolatedFileSystem(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(), fsid));
+}
+
+void PepperFileSystemBrowserHost::OpenPluginPrivateFileSystemComplete(
+    const std::string& fsid,
+    base::PlatformFileError error) {
+  int32 pp_error = ppapi::PlatformFileErrorToPepperError(error);
+  if (pp_error == PP_OK)
+    opened_ = true;
+  SendReplyForIsolatedFileSystem(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;
   }
+
+  reply_context_ = context->MakeReplyMessageContext();
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GetFileSystemContextFromRenderId, render_process_id),
       base::Bind(&PepperFileSystemBrowserHost::GotIsolatedFileSystemContext,
-                 weak_factory_.GetWeakPtr(),
-                 context->MakeReplyMessageContext()));
+                 weak_factory_.GetWeakPtr(), fsid, type));
   return PP_OK_COMPLETIONPENDING;
 }
 
+void PepperFileSystemBrowserHost::SendReplyForIsolatedFileSystem(
+    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() {
+  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();
+       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