Pepper: Stop using SRPC for irt_open_resource().

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 33 matching lines @@
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
 #include "ppapi/native_client/src/trusted/plugin/pnacl_resources.h"
 #include "ppapi/native_client/src/trusted/plugin/sel_ldr_launcher_chrome.h"
 #include "ppapi/native_client/src/trusted/plugin/srpc_client.h"
 #include "ppapi/native_client/src/trusted/plugin/utility.h"
 #include "ppapi/native_client/src/trusted/weak_ref/call_on_main_thread.h"
 
 namespace plugin {
 
-OpenManifestEntryResource::~OpenManifestEntryResource() {
-}
-
 PluginReverseInterface::PluginReverseInterface(
-    nacl::WeakRefAnchor* anchor,
     PP_Instance pp_instance,
     ServiceRuntime* service_runtime,
     pp::CompletionCallback init_done_cb,
     pp::CompletionCallback crash_cb)
-      : anchor_(anchor),
-        pp_instance_(pp_instance),
+      : pp_instance_(pp_instance),
         service_runtime_(service_runtime),
         shutting_down_(false),
         init_done_cb_(init_done_cb),
         crash_cb_(crash_cb) {
   NaClXMutexCtor(&mu_);
   NaClXCondVarCtor(&cv_);
 }
 
 PluginReverseInterface::~PluginReverseInterface() {
   NaClCondVarDtor(&cv_);
@@ skipping 21 matching lines @@
             "PluginReverseInterface::StartupInitializationComplete:"
             " invoking CB\n");
     pp::Module::Get()->core()->CallOnMainThread(0, init_done_cb_, PP_OK);
   } else {
     NaClLog(1,
             "PluginReverseInterface::StartupInitializationComplete:"
             " init_done_cb_ not valid, skipping.\n");
   }
 }
 
-// TODO(bsy): OpenManifestEntry should use the manifest to ResolveKey
-// 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);
-  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);
-  NaClLog(4,
-          "PluginReverseInterface::OpenManifestEntry:"
-          " waiting on main thread\n");
-
-  {
-    nacl::MutexLocker take(&mu_);
-    while (!shutting_down_ && !op_complete)
-      NaClXCondVarWait(&cv_, &mu_);
-    NaClLog(4, "PluginReverseInterface::OpenManifestEntry: done!\n");
-    if (shutting_down_) {
-      NaClLog(4,
-              "PluginReverseInterface::OpenManifestEntry:"
-              " plugin is shutting down\n");
-      return false;
-    }
-  }
-
-  // info->desc has the returned descriptor if successful, else -1.
-
-  // The caller is responsible for not closing info->desc.  If it is
-  // closed prematurely, then another open could re-use the OS
-  // descriptor, confusing the opened_ map.  If the caller is going to
-  // want to make a NaClDesc object and transfer it etc., then the
-  // caller should DUP the descriptor (but remember the original
-  // value) for use by the NaClDesc object, which closes when the
-  // object is destroyed.
-  NaClLog(4,
-          "PluginReverseInterface::OpenManifestEntry: info->desc = %d\n",
-          info->desc);
-  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;
-}
-
-// 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");
-
-  // Because p is owned by the callback of this invocation, so it is necessary
-  // to create another instance.
-  OpenManifestEntryResource* open_cont = new OpenManifestEntryResource(*p);
-  pp::CompletionCallback stream_cc = WeakRefNewCallback(
-      anchor_,
-      this,
-      &PluginReverseInterface::StreamAsFile_MainThreadContinuation,
-      open_cont);
-
-  GetNaClInterface()->OpenManifestEntry(
-      pp_instance_,
-      PP_FromBool(!service_runtime_->main_service_runtime()),
-      p->url.c_str(),
-      &open_cont->pp_file_info,
-      stream_cc.pp_completion_callback());
-  // 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) {
-      // We downloaded this file to temporary storage for this plugin; it's
-      // reasonable to provide a file descriptor with write access.
-      p->file_info->desc = ConvertFileDescriptor(p->pp_file_info.handle, false);
-      p->file_info->file_token.lo = p->pp_file_info.token_lo;
-      p->file_info->file_token.hi = p->pp_file_info.token_hi;
-      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_);
-  }
+  // Not implemented. See ManifestServiceChannel for where this logic happens
+  // now.
+  return false;
 }
 
 void PluginReverseInterface::ReportCrash() {
   NaClLog(4, "PluginReverseInterface::ReportCrash\n");
 
   if (crash_cb_.pp_completion_callback().func != NULL) {
     NaClLog(4, "PluginReverseInterface::ReportCrash: invoking CB\n");
     pp::Module::Get()->core()->CallOnMainThread(0, crash_cb_, PP_OK);
     // Clear the callback to avoid it gets invoked twice.
     crash_cb_ = pp::CompletionCallback();
@@ skipping 17 matching lines @@
                                PP_Instance pp_instance,
                                bool main_service_runtime,
                                bool uses_nonsfi_mode,
                                pp::CompletionCallback init_done_cb,
                                pp::CompletionCallback crash_cb)
     : plugin_(plugin),
       pp_instance_(pp_instance),
       main_service_runtime_(main_service_runtime),
       uses_nonsfi_mode_(uses_nonsfi_mode),
       reverse_service_(NULL),
-      anchor_(new nacl::WeakRefAnchor()),
-      rev_interface_(new PluginReverseInterface(anchor_, pp_instance, this,
+      rev_interface_(new PluginReverseInterface(pp_instance, this,
                                                 init_done_cb, crash_cb)),
       start_sel_ldr_done_(false),
       start_nexe_done_(false),
       nexe_started_ok_(false),
       bootstrap_channel_(NACL_INVALID_HANDLE) {
   NaClSrpcChannelInitialize(&command_channel_);
   NaClXMutexCtor(&mu_);
   NaClXCondVarCtor(&cond_);
 }
 
@@ skipping 304 matching lines @@
   NaClSrpcResultCodes rpc_result =
       NaClSrpcInvokeBySignature(&command_channel_,
                                 "log:is:",
                                 severity,
                                 strdup(msg.c_str()));
   return (NACL_SRPC_RESULT_OK == rpc_result);
 }
 
 void ServiceRuntime::Shutdown() {
   rev_interface_->ShutDown();
-  anchor_->Abandon();
   // Abandon callbacks, tell service threads to quit if they were
   // blocked waiting for main thread operations to finish.  Note that
   // some callbacks must still await their completion event, e.g.,
   // CallOnMainThread must still wait for the time out, or I/O events
   // must finish, so resources associated with pending events cannot
   // be deallocated.
 
   // Note that this does waitpid() to get rid of any zombie subprocess.
   subprocess_.reset(NULL);
 
@@ skipping 13 matching lines @@
 
 ServiceRuntime::~ServiceRuntime() {
   NaClLog(4, "ServiceRuntime::~ServiceRuntime (this=%p)\n",
           static_cast<void*>(this));
   // We do this just in case Shutdown() was not called.
   subprocess_.reset(NULL);
   if (reverse_service_ != NULL)
     reverse_service_->Unref();
 
   rev_interface_->Unref();
-
-  anchor_->Unref();
   NaClCondVarDtor(&cond_);
   NaClMutexDtor(&mu_);
 }
 
 void ServiceRuntime::set_exit_status(int exit_status) {
   nacl::MutexLocker take(&mu_);
   if (main_service_runtime_)
     plugin_->set_exit_status(exit_status & 0xff);
 }
 
 nacl::string ServiceRuntime::GetCrashLogOutput() {
   if (NULL != subprocess_.get()) {
     return subprocess_->GetCrashLogOutput();
   } else {
     return std::string();
   }
 }
 
 }  // namespace plugin