[PPAPI] It is now possible to pass a FileSystem to JS in PostMessage.

content/renderer/pepper/resource_converter.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/renderer/pepper/resource_converter.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/pepper_file_system_host.h"
 #include "content/renderer/pepper/pepper_media_stream_audio_track_host.h"
 #include "content/renderer/pepper/pepper_media_stream_video_track_host.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/host/resource_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/resource_var.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "third_party/WebKit/public/platform/WebFileSystem.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/web/WebDOMFileSystem.h"
 #include "third_party/WebKit/public/web/WebDOMMediaStreamTrack.h"
+#include "third_party/WebKit/public/web/WebFrame.h"
+#include "webkit/common/fileapi/file_system_util.h"
 
 using ppapi::ResourceVar;
 
 namespace content {
 namespace {
 
 void FlushComplete(
     const base::Callback<void(bool)>& callback,
     const std::vector<scoped_refptr<content::HostResourceVar> >& browser_vars,
     const std::vector<int>& pending_host_ids) {
@@ skipping 14 matching lines @@
     case blink::WebFileSystem::TypeIsolated:
       return PP_FILESYSTEMTYPE_ISOLATED;
     case blink::WebFileSystem::TypeExternal:
       return PP_FILESYSTEMTYPE_EXTERNAL;
     default:
       NOTREACHED();
       return PP_FILESYSTEMTYPE_LOCALTEMPORARY;
   }
 }
 
+// Converts a fileapi::FileSystemType to a blink::WebFileSystemType.
+// Returns true on success, false if |type| does not correspond to a
+// WebFileSystemType.
+bool FileApiFileSystemTypeToWebFileSystemType(
+    fileapi::FileSystemType type,
+    blink::WebFileSystemType* result_type) {
+  switch (type) {
+    case fileapi::kFileSystemTypeTemporary:
+      *result_type = blink::WebFileSystemTypeTemporary;
+      return true;
+    case fileapi::kFileSystemTypePersistent:
+      *result_type = blink::WebFileSystemTypePersistent;
+      return true;
+    case fileapi::kFileSystemTypeIsolated:
+      *result_type = blink::WebFileSystemTypeIsolated;
+      return true;
+    case fileapi::kFileSystemTypeExternal:
+      *result_type = blink::WebFileSystemTypeExternal;
+      return true;
+    default:
+      return false;
+  }
+}
+
 // Given a V8 value containing a DOMFileSystem, creates a resource host and
 // returns the resource information for serialization.
 // On error, false.
 bool DOMFileSystemToResource(
     PP_Instance instance,
     RendererPpapiHost* host,
     const blink::WebDOMFileSystem& dom_file_system,
     int* pending_renderer_id,
     scoped_ptr<IPC::Message>* create_message,
     scoped_ptr<IPC::Message>* browser_host_create_message) {
@@ skipping 18 matching lines @@
 
   create_message->reset(
       new PpapiPluginMsg_FileSystem_CreateFromPendingHost(file_system_type));
 
   browser_host_create_message->reset(
       new PpapiHostMsg_FileSystem_CreateFromRenderer(root_url.spec(),
                                                      file_system_type));
   return true;
 }
 
+bool ResourceHostToDOMFileSystem(
+    content::PepperFileSystemHost* file_system_host,
+    v8::Handle<v8::Context> context,
+    v8::Handle<v8::Value>* dom_file_system) {
+  GURL root_url = file_system_host->GetRootUrl();
+  GURL origin;
+  fileapi::FileSystemType type;
+  base::FilePath virtual_path;
+  fileapi::ParseFileSystemSchemeURL(root_url, &origin, &type, &virtual_path);
+
+  std::string name = fileapi::GetFileSystemName(origin, type);
+  blink::WebFileSystemType blink_type;
+  if (!FileApiFileSystemTypeToWebFileSystemType(type, &blink_type))
+    return false;
+  blink::WebFrame* frame = blink::WebFrame::frameForContext(context);
+  blink::WebDOMFileSystem web_dom_file_system = blink::WebDOMFileSystem::create(

[Ronghua Wu (Left Chromium), 2014/03/07 23:55:12]

Hi Matt,

In the video track case, the pepper host (PepperMediaStreamVideoTrackHost)
already owns a blink::WebMediaStreamTrack. I wonder do I need to associate that
track with |frame|? Or can I just simple get the v8::Value like below?


bool ResourceHostToDOMMediaStreamVideoTrack(
    content::PepperMediaStreamVideoTrackHost* host,
    v8::Handle<v8::Context> context,
    v8::Handle<v8::Value>* dom_video_track) {
  blink::WebMediaStreamTrack track = host->GetTrack();
  *dom_video_track = track.toV8Value();
  return true;
}

[Matt Giuca, 2014/03/10 04:51:42]

Since this isn't relevant to reviewing the CL, I'd prefer to discuss this
offline.

+      frame,
+      blink_type,
+      blink::WebString::fromUTF8(name),
+      root_url,
+      blink::WebDOMFileSystem::SerializableTypeSerializable);
+  *dom_file_system = web_dom_file_system.toV8Value();
+  return true;
+}
+
 bool DOMMediaStreamTrackToResource(
     PP_Instance instance,
     RendererPpapiHost* host,
     const blink::WebDOMMediaStreamTrack& dom_media_stream_track,
     int* pending_renderer_id,
     scoped_ptr<IPC::Message>* create_message) {
   DCHECK(!dom_media_stream_track.isNull());
   *pending_renderer_id = 0;
 
   const blink::WebMediaStreamTrack track = dom_media_stream_track.component();
@@ skipping 127 matching lines @@
   ::ppapi::host::PpapiHost* ppapi_host =
       renderer_ppapi_host->GetPpapiHost();
   ::ppapi::host::ResourceHost* resource_host =
       ppapi_host->GetResourceHost(resource_id);
   if (resource_host == NULL) {
     LOG(ERROR) << "No resource host for resource #" << resource_id;
     return false;
   }
 
   // Convert to the appropriate type of resource host.
-  // TODO(mgiuca): Convert FileSystemHost resources into DOMFileSystem V8
-  // objects. (http://crbug.com/345158)
-  LOG(ERROR) << "The type of resource #" << resource_id
-             << " cannot be converted to a JavaScript object.";
-  return false;
+  if (resource_host->IsFileSystemHost()) {
+    return ResourceHostToDOMFileSystem(
+        static_cast<content::PepperFileSystemHost*>(resource_host),
+        context,
+        result);
+  } else {
+    LOG(ERROR) << "The type of resource #" << resource_id
+               << " cannot be converted to a JavaScript object.";
+    return false;
+  }
 }
 
 scoped_refptr<HostResourceVar> ResourceConverterImpl::CreateResourceVar(
     int pending_renderer_id,
     const IPC::Message& create_message) {
   return new HostResourceVar(pending_renderer_id, create_message);
 }
 
 scoped_refptr<HostResourceVar>
 ResourceConverterImpl::CreateResourceVarWithBrowserHost(
     int pending_renderer_id,
     const IPC::Message& create_message,
     const IPC::Message& browser_host_create_message) {
   scoped_refptr<HostResourceVar> result =
       CreateResourceVar(pending_renderer_id, create_message);
   browser_host_create_messages_.push_back(browser_host_create_message);
   browser_vars.push_back(result);
   return result;
 }
 
 }  // namespace content