Pepper: Stop using SRPC for irt_open_resource().

components/nacl/loader/nacl_listener.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 "components/nacl/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 113 matching lines @@
     return false;
   return result;
 }
 
 void DebugStubPortSelectedHandler(uint16_t port) {
   g_listener->Send(new NaClProcessHostMsg_DebugStubPortSelected(port));
 }
 
 #endif
 
+// TODO(teravest): Decide if we should have a global callback here or look it
+// up in a map based on the token values.
+base::Callback<void(IPC::PlatformFileForTransit,
+                    base::FilePath)> g_resolved_cb;

[dmichael (off chromium), 2014/08/27 20:49:14]

I think the maybe map sounds best? I guess you're assuming you can only get 1 at
a time? If that's the case, at least a DCHECK or something that the Cb is
invalid would be good.

Also, I suspect this gives you a static initializer as-is...

[Mark Seaborn, 2014/08/28 23:40:22]

A mapping (from IDs to callbacks) would be better.  Can this be a member of the
NaClListener rather than a global?

[teravest, 2014/09/04 22:13:30]

open_resource() should only have one request in flight, so it's a bit simpler to
only have one live callback. I've moved this inside NaClListener.

I started to look at adding a map, but I realized it's possible to have two
open_resource() requests for the same file in flight, so the map would actually
have to be from a token to a queue of callbacks, which seems a little gross.

I think if we want open_resource() to support multiple requests in-flight, that
should happen in another change. Let me know if that's unreasonable.

+
+void ResolveFileToken(
+    uint64_t token_lo,
+    uint64_t token_hi,
+    base::Callback<void(IPC::PlatformFileForTransit,
+                        base::FilePath)> resolved_cb) {
+  if (!g_listener)
+    resolved_cb.Run(IPC::PlatformFileForTransit(), base::FilePath());
+  base::FilePath file_path;
+  if (g_listener->Send(new NaClProcessMsg_ResolveFileTokenAsync(token_lo,
+                                                                token_hi)))
+    g_resolved_cb = resolved_cb;
+  else
+    resolved_cb.Run(IPC::PlatformFileForTransit(), base::FilePath());
+}
+
 // Creates the PPAPI IPC channel between the NaCl IRT and the host
 // (browser/renderer) process, and starts to listen it on the thread where
 // the given message_loop_proxy runs.
 // Also, creates and sets the corresponding NaClDesc to the given nap with
 // the FD #.
-void SetUpIPCAdapter(IPC::ChannelHandle* handle,
-                     scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
-                     struct NaClApp* nap,
-                     int nacl_fd) {
+scoped_refptr<NaClIPCAdapter> SetUpIPCAdapter(
+    IPC::ChannelHandle* handle,
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    struct NaClApp* nap,
+    int nacl_fd) {
   scoped_refptr<NaClIPCAdapter> ipc_adapter(
       new NaClIPCAdapter(*handle, message_loop_proxy.get()));
   ipc_adapter->ConnectChannel();
 #if defined(OS_POSIX)
   handle->socket =
       base::FileDescriptor(ipc_adapter->TakeClientFileDescriptor(), true);
 #endif
 
   // Pass a NaClDesc to the untrusted side. This will hold a ref to the
   // NaClIPCAdapter.
   NaClAppSetDesc(nap, nacl_fd, ipc_adapter->MakeNaClDesc());
+  return ipc_adapter;
 }
 
 }  // namespace
 
 class BrowserValidationDBProxy : public NaClValidationDB {
  public:
   explicit BrowserValidationDBProxy(NaClListener* listener)
       : listener_(listener) {
   }
 
@@ skipping 80 matching lines @@
   DCHECK(main_loop_ != NULL);
   if (base::MessageLoop::current() == main_loop_) {
     // This thread owns the channel.
     return channel_->Send(msg);
   } else {
     // This thread does not own the channel.
     return filter_->Send(msg);
   }
 }
 
+class FileTokenMessageFilter : public IPC::MessageFilter {
+ public:
+  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {

[Mark Seaborn, 2014/08/28 23:40:22]

Why is this handled in a new MessageFilter?  Can't the new message be handled in
NaClListener::OnMessageReceived() below?

[teravest, 2014/09/04 22:13:30]

This has to be handled in a new MessageFilter so that this work can run on the
IO thread. The main thread used by NaClListener is taken up by
NaClChromeMainAppStart(), so it can't be used for servicing messages.

[Mark Seaborn, 2014/09/09 04:42:29]

Makes sense.  Can you add that as a comment on FileTokenMessageFilter, please?

[teravest, 2014/09/09 16:49:06]

Done.

+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(FileTokenMessageFilter, msg)
+      IPC_MESSAGE_HANDLER(NaClProcessMsg_ResolveFileTokenAsyncReply,
+                          OnResolveFileTokenAsyncReply)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+  void OnResolveFileTokenAsyncReply(
+      uint64_t token_lo,
+      uint64_t token_hi,
+      IPC::PlatformFileForTransit ipc_fd,
+      base::FilePath file_path) {
+    // TODO: Replace this with a token lookup.
+    g_resolved_cb.Run(ipc_fd, file_path);
+    g_resolved_cb.Reset();
+  }
+ private:
+  virtual ~FileTokenMessageFilter() { }
+};
+
 void NaClListener::Listen() {
   std::string channel_name =
       CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID);
   channel_ = IPC::SyncChannel::Create(
       this, io_thread_.message_loop_proxy().get(), &shutdown_event_);
   filter_ = new IPC::SyncMessageFilter(&shutdown_event_);
   channel_->AddFilter(filter_.get());
+  channel_->AddFilter(new FileTokenMessageFilter());
   channel_->Init(channel_name, IPC::Channel::MODE_CLIENT, true);
   main_loop_ = base::MessageLoop::current();
   main_loop_->Run();
 }
 
 bool NaClListener::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClListener, msg)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_Start, OnStart)
       IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 19 matching lines @@
   NaClSetFatalErrorCallback(&FatalLogHandler);
 
   nap = NaClAppCreate();
   if (nap == NULL) {
     LOG(ERROR) << "NaClAppCreate() failed";
     return;
   }
 
   IPC::ChannelHandle browser_handle;
   IPC::ChannelHandle ppapi_renderer_handle;
+  IPC::ChannelHandle manifest_service_handle;
 
   if (params.enable_ipc_proxy) {
     browser_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     ppapi_renderer_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
+    manifest_service_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
 
     // Create the PPAPI IPC channels between the NaCl IRT and the host
     // (browser/renderer) processes. The IRT uses these channels to
     // communicate with the host and to initialize the IPC dispatchers.
     SetUpIPCAdapter(&browser_handle, io_thread_.message_loop_proxy(),
                     nap, NACL_CHROME_DESC_BASE);
     SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.message_loop_proxy(),
                     nap, NACL_CHROME_DESC_BASE + 1);
+
+    scoped_refptr<NaClIPCAdapter> manifest_ipc_adapter =
+        SetUpIPCAdapter(&manifest_service_handle,
+                        io_thread_.message_loop_proxy(),
+                        nap,
+                        NACL_CHROME_DESC_BASE + 2);
+    manifest_ipc_adapter->set_resolve_file_token_callback(
+        base::Bind(&ResolveFileToken));
   }
 
   trusted_listener_ = new NaClTrustedListener(
       IPC::Channel::GenerateVerifiedChannelID("nacl"),
       io_thread_.message_loop_proxy().get(),
       &shutdown_event_);
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
           browser_handle,
           ppapi_renderer_handle,
           trusted_listener_->TakeClientChannelHandle(),
-          IPC::ChannelHandle())))
+          manifest_service_handle)))
     LOG(ERROR) << "Failed to send IPC channel handle to NaClProcessHost.";
 
   std::vector<nacl::FileDescriptor> handles = params.handles;
   struct NaClChromeMainArgs* args = NaClChromeMainArgsCreate();
   if (args == NULL) {
     LOG(ERROR) << "NaClChromeMainArgsCreate() failed";
     return;
   }
 
 #if defined(OS_LINUX) || defined(OS_MACOSX)
@@ skipping 86 matching lines @@
   args->nexe_desc = NaClDescIoFromFileInfo(nexe_file_info, NACL_ABI_O_RDONLY);
 
   int exit_status;
   if (!NaClChromeMainStart(nap, args, &exit_status))
     NaClExit(1);
 
   // Report the plugin's exit status if the application started successfully.
   trusted_listener_->Send(new NaClRendererMsg_ReportExitStatus(exit_status));
   NaClExit(exit_status);
 }