Implement open_resource in non-SFI mode.

ppapi/native_client/src/trusted/plugin/service_runtime.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.
  */
 
 #define NACL_LOG_MODULE_NAME "Plugin_ServiceRuntime"
 
 #include "ppapi/native_client/src/trusted/plugin/service_runtime.h"
 
@@ skipping 46 matching lines @@
 
 namespace plugin {
 namespace {
 
 // For doing crude quota enforcement on writes to temp files.
 // We do not allow a temp file bigger than 128 MB for now.
 // There is currently a limit of 32M for nexe text size, so 128M
 // should be plenty for static data
 const int64_t kMaxTempQuota = 0x8000000;
 
+class OpenManifestEntryAsyncCallback {
+ public:
+  OpenManifestEntryAsyncCallback(PP_FileHandle* file_handle,
+                                 const pp::CompletionCallback& callback)
+      : file_handle_(file_handle),
+        callback_(callback) {
+  }
+
+  ~OpenManifestEntryAsyncCallback() {
+    if (callback_.pp_completion_callback().func)
+      callback_.RunAndClear(PP_ERROR_ABORTED);
+  }
+
+  void Run(int32_t pp_error) {
+#if defined(OS_WIN)
+    // Currently, this is used only for non-SFI mode, and now the mode is not
+    // supproted on windows.
+    // TODO(hidehiko): Support it on Windows when we switch to use
+    // ManifestService also in SFI-mode.
+    NACL_NOTREACHED();
+#elif defined(OS_POSIX)
+    // On posix, PlatformFile is the file descriptor.
+    *file_handle_ = (pp_error == PP_OK) ? info_.desc : -1;
+#endif
+    callback_.RunAndClear(pp_error);
+    delete this;
+  }
+
+  NaClFileInfo* mutable_info() { return &info_; }
+  pp::CompletionCallback pp_completion_callback() {
+    return pp::CompletionCallback(&RunTrampoline, this);
+  }
+
+ private:
+  static void RunTrampoline(void* user_data, int32_t pp_error) {
+    static_cast<OpenManifestEntryAsyncCallback*>(user_data)->Run(pp_error);
+  }
+
+  PP_FileHandle* file_handle_;
+  NaClFileInfo info_;
+  pp::CompletionCallback callback_;
+  DISALLOW_COPY_AND_ASSIGN(OpenManifestEntryAsyncCallback);
+};
+
 class ManifestService {
  public:
   ManifestService(nacl::WeakRefAnchor* anchor,
                   PluginReverseInterface* plugin_reverse)
       : anchor_(anchor),
         plugin_reverse_(plugin_reverse) {
   }
 
   ~ManifestService() {
     anchor_->Unref();
   }
 
   bool Quit() {
     delete this;
     return false;
   }
 
   bool StartupInitializationComplete() {
     // Release this instance if the ServiceRuntime is already destructed.
     if (anchor_->is_abandoned()) {
       delete this;
       return false;
     }
 
     plugin_reverse_->StartupInitializationComplete();
     return true;
   }
 
+  bool OpenResource(const char* entry_key, PP_FileHandle* file,
+                    const pp::CompletionCallback& callback) {
+    // Release this instance if the ServiceRuntime is already destructed.
+    if (anchor_->is_abandoned()) {
+      delete this;
+      return false;
+    }
+
+    OpenManifestEntryAsyncCallback* open_manifest_callback =
+        new OpenManifestEntryAsyncCallback(file, callback);
+    plugin_reverse_->OpenManifestEntryAsync(
+        entry_key,
+        open_manifest_callback->mutable_info(),
+        open_manifest_callback->pp_completion_callback());
+    return true;
+  }
+
   static PP_Bool QuitTrampoline(void* user_data) {
     return PP_FromBool(static_cast<ManifestService*>(user_data)->Quit());
   }
 
   static PP_Bool StartupInitializationCompleteTrampoline(void* user_data) {
     return PP_FromBool(static_cast<ManifestService*>(user_data)->
                        StartupInitializationComplete());
   }
 
+  static PP_Bool OpenResourceTrampoline(
+      void* user_data, const char* entry_key, PP_FileHandle* file,
+      struct PP_CompletionCallback callback) {
+    return PP_FromBool(
+        static_cast<ManifestService*>(user_data)->OpenResource(
+            entry_key, file,
+            pp::CompletionCallback(callback.func, callback.user_data)));
+  }
+
  private:
   // Weak reference to check if plugin_reverse is legally accessible or not.
   nacl::WeakRefAnchor* anchor_;
   PluginReverseInterface* plugin_reverse_;
 
   DISALLOW_COPY_AND_ASSIGN(ManifestService);
 };
 
 // Vtable to pass functions to LaunchSelLdr.
-const PP_ManifestService kManifestServiceVTable = {
+const PPB_ManifestService kManifestServiceVTable = {
   &ManifestService::QuitTrampoline,
   &ManifestService::StartupInitializationCompleteTrampoline,
+  &ManifestService::OpenResourceTrampoline,
 };
 
 }  // namespace
 
 PluginReverseInterface::PluginReverseInterface(
     nacl::WeakRefAnchor* anchor,
     Plugin* plugin,
     const Manifest* manifest,
     ServiceRuntime* service_runtime,
     pp::CompletionCallback init_done_cb,
@@ skipping 67 matching lines @@
 // and invoke StreamAsFile with a completion callback that invokes
 // GetPOSIXFileDesc.
 bool PluginReverseInterface::OpenManifestEntry(nacl::string url_key,
                                                struct NaClFileInfo* info) {
   bool op_complete = false;  // NB: mu_ and cv_ also controls access to this!
   // The to_open object is owned by the weak ref callback. Because this function
   // waits for the callback to finish, the to_open object will be deallocated on
   // the main thread before this function can return. The pointers it contains
   // to stack variables will not leak.
   OpenManifestEntryResource* to_open =
-      new OpenManifestEntryResource(url_key, info, &op_complete);
+      new OpenManifestEntryResource(url_key, info, &op_complete,
+                                    pp::CompletionCallback());
   CHECK(to_open != NULL);
   NaClLog(4, "PluginReverseInterface::OpenManifestEntry: %s\n",
           url_key.c_str());
   // This assumes we are not on the main thread.  If false, we deadlock.
   plugin::WeakRefCallOnMainThread(
       anchor_,
       0,
       this,
       &plugin::PluginReverseInterface::OpenManifestEntry_MainThreadContinuation,
       to_open);
@@ skipping 29 matching lines @@
   if (info->desc == -1) {
     // TODO(bsy,ncbray): what else should we do with the error?  This
     // is a runtime error that may simply be a programming error in
     // the untrusted code, or it may be something else wrong w/ the
     // manifest.
     NaClLog(4, "OpenManifestEntry: failed for key %s", url_key.c_str());
   }
   return true;
 }
 
+void PluginReverseInterface::OpenManifestEntryAsync(
+    const nacl::string& entry_key,
+    struct NaClFileInfo* info,
+    const pp::CompletionCallback& callback) {
+  bool op_complete = false;
+  OpenManifestEntryResource to_open(
+      entry_key, info, &op_complete, callback);

[teravest, 2014/04/24 20:00:52]

Do we need to pass a callback into OpenManifestEntryResource here?
It looks like OpenManifestEntry_MainThreadContinuation is effectively
synchronous.

Why does OpenManifestEntryAsync take a callback at all? I feel like I'm missing
something.

This is calling OpenManifestEntry_MainThreadContinuation, so I don't think
there's any call having to happen across threads...

[hidehiko, 2014/04/25 05:53:54]

OpenManifestEntry can be called only on a non-main thread
(if it is called on the main thread, it'd just hung up),
but the ManifestService::OpenResource is called on the main thread.

The implementation of OpenManifestEntry (i.e.
OpenManifestEntry_MainThreadContinuation and
StreamAsFile_MainThreadContinuation) is async call (pls see also around
L430-L436), so that we need its completion callback.

The reason why it's an async call is that, in some cases, opening the stream
triggers async IPC with the browser, so it needs to wait for its reply.

+  OpenManifestEntry_MainThreadContinuation(&to_open, PP_OK);
+}
+
 // Transfer point from OpenManifestEntry() which runs on the main thread
 // (Some PPAPI actions -- like StreamAsFile -- can only run on the main thread).
 // OpenManifestEntry() is waiting on a condvar for this continuation to
 // complete.  We Broadcast and awaken OpenManifestEntry() whenever we are done
 // either here, or in a later MainThreadContinuation step, if there are
 // multiple steps.
 void PluginReverseInterface::OpenManifestEntry_MainThreadContinuation(
     OpenManifestEntryResource* p,
     int32_t err) {
   UNREFERENCED_PARAMETER(err);
   // CallOnMainThread continuations always called with err == PP_OK.
 
   NaClLog(4, "Entered OpenManifestEntry_MainThreadContinuation\n");
 
   std::string mapped_url;
   PP_PNaClOptions pnacl_options = {PP_FALSE, PP_FALSE, 2};
   ErrorInfo error_info;
   if (!manifest_->ResolveKey(p->url, &mapped_url,
                              &pnacl_options, &error_info)) {
     NaClLog(4, "OpenManifestEntry_MainThreadContinuation: ResolveKey failed\n");
     NaClLog(4,
             "Error code %d, string %s\n",
             error_info.error_code(),
             error_info.message().c_str());
     // Failed, and error_info has the details on what happened.  Wake
     // up requesting thread -- we are done.
-    nacl::MutexLocker take(&mu_);
-    *p->op_complete_ptr = true;  // done...
-    p->file_info->desc = -1;  // but failed.
-    NaClXCondVarBroadcast(&cv_);
+    {
+      nacl::MutexLocker take(&mu_);
+      *p->op_complete_ptr = true;  // done...
+      p->file_info->desc = -1;  // but failed.
+      NaClXCondVarBroadcast(&cv_);
+    }
+    if (p->callback.pp_completion_callback().func)
+      p->callback.RunAndClear(PP_OK);
     return;
   }
   NaClLog(4,
           "OpenManifestEntry_MainThreadContinuation: "
           "ResolveKey: %s -> %s (pnacl_translate(%d))\n",
           p->url.c_str(), mapped_url.c_str(), pnacl_options.translate);
 
   if (pnacl_options.translate) {
     // Requires PNaCl translation, but that's not supported.
     NaClLog(4,
             "OpenManifestEntry_MainThreadContinuation: "
             "Requires PNaCl translation -- not supported\n");
-    nacl::MutexLocker take(&mu_);
-    *p->op_complete_ptr = true;  // done...
-    p->file_info->desc = -1;  // but failed.
-    NaClXCondVarBroadcast(&cv_);
+    {
+      nacl::MutexLocker take(&mu_);
+      *p->op_complete_ptr = true;  // done...
+      p->file_info->desc = -1;  // but failed.
+      NaClXCondVarBroadcast(&cv_);
+    }
+    if (p->callback.pp_completion_callback().func)
+      p->callback.RunAndClear(PP_OK);
     return;
   }
 
   if (PnaclUrls::IsPnaclComponent(mapped_url)) {
     // Special PNaCl support files, that are installed on the
     // user machine.
     int32_t fd = PnaclResources::GetPnaclFD(
         plugin_,
         PnaclUrls::PnaclComponentURLToFilename(mapped_url).c_str());
     if (fd < 0) {
       // We checked earlier if the pnacl component wasn't installed
       // yet, so this shouldn't happen. At this point, we can't do much
       // anymore, so just continue with an invalid fd.
       NaClLog(4,
               "OpenManifestEntry_MainThreadContinuation: "
               "GetReadonlyPnaclFd failed\n");
     }
-    nacl::MutexLocker take(&mu_);
-    *p->op_complete_ptr = true;  // done!
-    // TODO(ncbray): enable the fast loading and validation paths for this
-    // type of file.
-    p->file_info->desc = fd;
-    NaClXCondVarBroadcast(&cv_);
+    {
+      nacl::MutexLocker take(&mu_);
+      *p->op_complete_ptr = true;  // done!
+      // TODO(ncbray): enable the fast loading and validation paths for this
+      // type of file.
+      p->file_info->desc = fd;
+      NaClXCondVarBroadcast(&cv_);
+    }
     NaClLog(4,
             "OpenManifestEntry_MainThreadContinuation: GetPnaclFd okay\n");
+    if (p->callback.pp_completion_callback().func)
+      p->callback.RunAndClear(PP_OK);
     return;
   }
 
   // Hereafter, normal files.
 
   // Because p is owned by the callback of this invocation, so it is necessary
   // to create another instance.
   OpenManifestEntryResource* open_cont = new OpenManifestEntryResource(*p);
   open_cont->url = mapped_url;
+  // Callback is now delegated from p to open_cont. So, here we manually clear
+  // complete callback.
+  p->callback = pp::CompletionCallback();
   pp::CompletionCallback stream_cc = WeakRefNewCallback(
       anchor_,
       this,
       &PluginReverseInterface::StreamAsFile_MainThreadContinuation,
       open_cont);
 
   if (!plugin_->StreamAsFile(mapped_url, stream_cc)) {
     NaClLog(4,
             "OpenManifestEntry_MainThreadContinuation: "
             "StreamAsFile failed\n");
     // Here, StreamAsFile is failed and stream_cc is not called.
     // However, open_cont will be released only by the invocation.
     // So, we manually call it here with error.
     stream_cc.Run(PP_ERROR_FAILED);
     return;
   }
 
   NaClLog(4, "OpenManifestEntry_MainThreadContinuation: StreamAsFile okay\n");
   // p is deleted automatically
 }
 
 void PluginReverseInterface::StreamAsFile_MainThreadContinuation(
     OpenManifestEntryResource* p,
     int32_t result) {
   NaClLog(4,
           "Entered StreamAsFile_MainThreadContinuation\n");
 
-  nacl::MutexLocker take(&mu_);
-  if (result == PP_OK) {
-    NaClLog(4, "StreamAsFile_MainThreadContinuation: GetFileInfo(%s)\n",
-            p->url.c_str());
-    *p->file_info = plugin_->GetFileInfo(p->url);
+  {
+    nacl::MutexLocker take(&mu_);
+    if (result == PP_OK) {
+      NaClLog(4, "StreamAsFile_MainThreadContinuation: GetFileInfo(%s)\n",
+              p->url.c_str());
+      *p->file_info = plugin_->GetFileInfo(p->url);
 
-    NaClLog(4,
-            "StreamAsFile_MainThreadContinuation: PP_OK, desc %d\n",
-            p->file_info->desc);
-  } else {
-    NaClLog(4,
-            "StreamAsFile_MainThreadContinuation: !PP_OK, setting desc -1\n");
-    p->file_info->desc = -1;
+      NaClLog(4,
+              "StreamAsFile_MainThreadContinuation: PP_OK, desc %d\n",
+              p->file_info->desc);
+    } else {
+      NaClLog(
+          4,
+          "StreamAsFile_MainThreadContinuation: !PP_OK, setting desc -1\n");
+      p->file_info->desc = -1;
+    }
+    *p->op_complete_ptr = true;
+    NaClXCondVarBroadcast(&cv_);
   }
-  *p->op_complete_ptr = true;
-  NaClXCondVarBroadcast(&cv_);
+  if (p->callback.pp_completion_callback().func)
+    p->callback.RunAndClear(PP_OK);
 }
 
 bool PluginReverseInterface::CloseManifestEntry(int32_t desc) {
   bool op_complete = false;
   bool op_result;
   CloseManifestEntryResource* to_close =
       new CloseManifestEntryResource(desc, &op_complete, &op_result);
 
   plugin::WeakRefCallOnMainThread(
       anchor_,
@@ skipping 415 matching lines @@
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin