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
 
+// This function should be used be provided to the ManifestChannel

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

Remove "be used"?

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

I've removed this function. You're correct that NaClListener isn't destroyed, so
the indirection provided by this function is unnecessary.

+// NaClIPCAdapter instead of the one inside NaClListener; this one will always

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

You mean instead of the one in BrowserValidationDBProxy, right?

Can you comment that this is the "new" version of ResolveFileToken?

Oh, you do you mean the NaClListener::ResolveFileToken() you're adding.  It's
confusing that there's 3 ResolveFileToken()s.  Could you distinguish them more?

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

Acknowledged.

+// run the callback, even if the NaClListener has been destroyed.

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

I'm pretty sure NaClListener never gets destroyed.  Its Listen() method runs an
event loop that shouldn't exit.  Rather than trying to handle something that
won't happen (and can't be tested), how about doing CHECK(g_listener)?

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

Acknowledged.

+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());
+  g_listener->ResolveFileToken(token_lo, token_hi, resolved_cb);
+}
+
 // 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 10 matching lines @@
     return result;
   }
 
   virtual void SetKnownToValidate(const std::string& signature) OVERRIDE {
     // Caching is optional: NaCl will still work correctly if the IPC fails.
     if (!listener_->Send(new NaClProcessMsg_SetKnownToValidate(signature))) {
       LOG(ERROR) << "Failed to update NaCl validation cache.";
     }
   }
 
   virtual bool ResolveFileToken(struct NaClFileToken* file_token,

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

Isn't this now only used for the initial nexe?  Can you comment that, and mark
it as the "old" code path?

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

Done.

                                 int32* fd, std::string* path) OVERRIDE {
     *fd = -1;
     *path = "";
     if (!NaClFileTokenIsValid(file_token)) {
       return false;
     }
     IPC::PlatformFileForTransit ipc_fd = IPC::InvalidPlatformFileForTransit();
     base::FilePath ipc_path;
     if (!listener_->Send(new NaClProcessMsg_ResolveFileToken(file_token->lo,
                                                              file_token->hi,
@@ skipping 49 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 {
+    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) {
+    if (g_listener)

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

Make this a CHECK() too?

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

Done.

+      g_listener->OnFileTokenResolved(token_lo, token_hi, ipc_fd, file_path);
+  }
+ 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);
 }
+
+void NaClListener::ResolveFileToken(
+    uint64_t token_lo,
+    uint64_t token_hi,
+    base::Callback<void(IPC::PlatformFileForTransit, base::FilePath)> cb) {
+  if (!Send(new NaClProcessMsg_ResolveFileTokenAsync(token_lo, token_hi))) {
+    cb.Run(IPC::PlatformFileForTransit(), base::FilePath());
+    return;
+  }
+  resolved_cb_ = cb;
+}
+
+void NaClListener::OnFileTokenResolved(
+    uint64_t token_lo,
+    uint64_t token_hi,
+    IPC::PlatformFileForTransit ipc_fd,
+    base::FilePath file_path) {
+  resolved_cb_.Run(ipc_fd, file_path);
+  resolved_cb_.Reset();
+}