[PPAPI] It is now possible to pass filesystems from JavaScript to NaCl modules.

ppapi/proxy/plugin_var_tracker.cc

 // Copyright (c) 2012 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 "ppapi/proxy/plugin_var_tracker.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
+#include "ipc/ipc_message.h"
 #include "ppapi/c/dev/ppp_class_deprecated.h"
 #include "ppapi/c/ppb_var.h"
+#include "ppapi/proxy/file_system_resource.h"
 #include "ppapi/proxy/plugin_array_buffer_var.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_resource_var.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/proxy_object_var.h"
 #include "ppapi/shared_impl/api_id.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/var.h"
 
 namespace ppapi {
 namespace proxy {
 
+namespace {
+
+// Should only be called when the Pepper plugin is out of process.
+Connection GetConnectionForInstance(PP_Instance instance) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  // GetForInstance returns NULL in the in-process case.

[raymes, 2013/10/30 06:31:51]

nit: PluginDispatcher::GetForInstance returns NULL...

[Matt Giuca, 2013/10/30 07:00:39]

Done.

+  DCHECK(dispatcher);
+  return Connection(PluginGlobals::Get()->GetBrowserSender(), dispatcher);
+}
+
+}  // namespace
+
 PluginVarTracker::HostVar::HostVar(PluginDispatcher* d, int32 i)
     : dispatcher(d),
       host_object_id(i) {
 }
 
 bool PluginVarTracker::HostVar::operator<(const HostVar& other) const {
   if (dispatcher < other.dispatcher)
     return true;
   if (other.dispatcher < dispatcher)
     return false;
@@ skipping 112 matching lines @@
       HostVar(dispatcher, static_cast<int32>(host_object.value.as_id)));
   if (found == host_var_to_plugin_var_.end()) {
     NOTREACHED();
     return;
   }
 
   // Now just release the object given the plugin var ID.
   ReleaseVar(found->second);
 }
 
+PP_Var PluginVarTracker::MakeResourcePPVar(const IPC::Message& creation_message,
+                                           int pending_renderer_id,
+                                           int pending_browser_id,
+                                           PP_Instance instance) {
+  DCHECK(pending_renderer_id);
+  DCHECK(pending_browser_id);
+  switch (creation_message.type()) {
+    case PpapiPluginMsg_FileSystem_CreateFromPendingHost::ID: {
+      PP_FileSystemType file_system_type;
+      if (!UnpackMessage<PpapiPluginMsg_FileSystem_CreateFromPendingHost>(
+               creation_message, &file_system_type)) {
+        NOTREACHED() << "Invalid message of type "
+                        "PpapiPluginMsg_FileSystem_CreateFromPendingHost";
+        return PP_MakeNull();
+      }
+      // Create a plugin-side resource and attach it to the host resource.
+      // Note: This only makes sense when the plugin is out of process (which
+      // should always be true when passing resource vars).
+      PP_Resource pp_resource =
+          (new FileSystemResource(GetConnectionForInstance(instance),
+                                  instance,
+                                  pending_renderer_id,
+                                  pending_browser_id,
+                                  file_system_type))->GetReference();
+      return VarTracker::MakeResourcePPVar(pp_resource);

[raymes, 2013/10/30 06:31:51]

nit: does this have to be qualified? Why not just call MakeResourceVar?

[Matt Giuca, 2013/10/30 07:00:39]

Something weird with the C++ compiler. Because the subclass overrides
MakeResourceVar with 4 arguments, but not the 1-argument version, apparently if
you just call MakeResourceVar from the subclass, it doesn't know about the
4-argument version. I had to qualify it.

[dmichael (off chromium), 2013/10/30 17:47:27]

It's called name hiding; the compiler is required to do this by the C++
standard. I would recommend avoiding the problem entirely by giving one of the
functions a different name. (E.g., MakeResourcePPVarFromMessage or something).

[Matt Giuca, 2013/10/30 23:13:53]

Done.

+    }
+    default: {
+      NOTREACHED() << "Creation message has unexpected type "
+                   << creation_message.type();
+      return PP_MakeNull();
+    }
+  }
+}
+
 ResourceVar* PluginVarTracker::MakeResourceVar(PP_Resource pp_resource) {
   // The resource 0 returns a null resource var.
   if (!pp_resource)
     return new PluginResourceVar();
 
   ResourceTracker* resource_tracker = PpapiGlobals::Get()->GetResourceTracker();
   ppapi::Resource* resource = resource_tracker->GetResource(pp_resource);
   // A non-existant resource other than 0 returns NULL.
   if (!resource)
     return NULL;
@@ skipping 255 matching lines @@
     int id,
     PP_Instance instance,
     base::SharedMemoryHandle* handle,
     uint32* size_in_bytes) {
   NOTREACHED();
   return false;
 }
 
 }  // namesace proxy
 }  // namespace ppapi