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) {
+    *file_handle_ = (pp_error == PP_OK) ? info_.desc : -1;
+    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);
+  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