PNaCl on-demand installs: Make a separate async IPC to check if PNaCl is installed

chrome/renderer/pepper/pnacl_translation_resource_host.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 "pnacl_translation_resource_host.h"
 
 #ifndef DISABLE_NACL
 #include "components/nacl/common/nacl_host_messages.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 
 using ppapi::TrackedCallback;
 using ppapi::PpapiGlobals;
 
 PnaclTranslationResourceHost::CacheRequestInfo::CacheRequestInfo(
     PP_Bool* hit,
     PP_FileHandle* handle,
     scoped_refptr<TrackedCallback> cb)
     : is_hit(hit), file_handle(handle), callback(cb) {}
 
 PnaclTranslationResourceHost::CacheRequestInfo::~CacheRequestInfo() {}
 
 PnaclTranslationResourceHost::PnaclTranslationResourceHost(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
     : io_message_loop_(io_message_loop), channel_(NULL) {}
 
 PnaclTranslationResourceHost::~PnaclTranslationResourceHost() {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   CleanupCacheRequests();
+  CleanupEnsurePnaclRequests();
 }
 
 void PnaclTranslationResourceHost::OnFilterAdded(IPC::Channel* channel) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   channel_ = channel;
 }
 
 void PnaclTranslationResourceHost::OnFilterRemoved() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   channel_ = NULL;
 }
 
 void PnaclTranslationResourceHost::OnChannelClosing() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   channel_ = NULL;
 }
 
 bool PnaclTranslationResourceHost::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PnaclTranslationResourceHost, message)
     IPC_MESSAGE_HANDLER(NaClViewMsg_NexeTempFileReply, OnNexeTempFileReply)
+    IPC_MESSAGE_HANDLER(NaClViewMsg_EnsurePnaclInstalledReply,
+                        OnEnsurePnaclInstalledReply)
+    IPC_MESSAGE_HANDLER(NaClViewMsg_EnsurePnaclInstalledProgress,
+                        OnEnsurePnaclInstalledProgress)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PnaclTranslationResourceHost::RequestNexeFd(
     int render_view_id,
     PP_Instance instance,
     const nacl::PnaclCacheInfo& cache_info,
     PP_Bool* is_hit,
     PP_FileHandle* file_handle,
     scoped_refptr<TrackedCallback> callback) {
+  DCHECK(PpapiGlobals::Get()->
+         GetMainThreadMessageLoop()->BelongsToCurrentThread());
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&PnaclTranslationResourceHost::SendRequestNexeFd,
+                 this,
+                 render_view_id,
+                 instance,
+                 cache_info,
+                 is_hit,
+                 file_handle,
+                 callback));
+  return;
+}
 
-  if (!io_message_loop_->BelongsToCurrentThread()) {
-    io_message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&PnaclTranslationResourceHost::RequestNexeFd,
-                   this,
-                   render_view_id,
-                   instance,
-                   cache_info,
-                   is_hit,
-                   file_handle,
-                   callback));
-    return;
-  }
+void PnaclTranslationResourceHost::SendRequestNexeFd(
+    int render_view_id,
+    PP_Instance instance,
+    const nacl::PnaclCacheInfo& cache_info,
+    PP_Bool* is_hit,
+    PP_FileHandle* file_handle,
+    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   if (!channel_ || !channel_->Send(new NaClHostMsg_NexeTempFileRequest(
                        render_view_id, instance, cache_info))) {
     PpapiGlobals::Get()->GetMainThreadMessageLoop()
         ->PostTask(FROM_HERE,
                    base::Bind(&TrackedCallback::Run,
                               callback,
                               static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
   pending_cache_requests_.insert(std::make_pair(
       instance, CacheRequestInfo(is_hit, file_handle, callback)));
 }
 
 void PnaclTranslationResourceHost::ReportTranslationFinished(
     PP_Instance instance) {
-  if (!io_message_loop_->BelongsToCurrentThread()) {
-    io_message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&PnaclTranslationResourceHost::ReportTranslationFinished,
-                   this,
-                   instance));
-    return;
-  }
+  DCHECK(PpapiGlobals::Get()->
+         GetMainThreadMessageLoop()->BelongsToCurrentThread());
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&PnaclTranslationResourceHost::SendReportTranslationFinished,
+                 this,
+                 instance));
+  return;
+}
+
+void PnaclTranslationResourceHost::SendReportTranslationFinished(
+    PP_Instance instance) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   // If the channel is closed or we have been detached, we are probably shutting
   // down, so just don't send anything.
   if (!channel_)
     return;
   DCHECK(pending_cache_requests_.count(instance) == 0);
   channel_->Send(new NaClHostMsg_ReportTranslationFinished(instance));
 }
 
 void PnaclTranslationResourceHost::OnNexeTempFileReply(
     PP_Instance instance,
     bool is_hit,
     IPC::PlatformFileForTransit file) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   CacheRequestInfoMap::iterator it = pending_cache_requests_.find(instance);
   int32_t status = PP_ERROR_FAILED;
   // Handle the expected successful case first.
   if (it != pending_cache_requests_.end() &&
       !(file == IPC::InvalidPlatformFileForTransit()) &&
       TrackedCallback::IsPending(it->second.callback)) {
     *it->second.is_hit = PP_FromBool(is_hit);
     *it->second.file_handle = IPC::PlatformFileForTransitToPlatformFile(file);
     status = PP_OK;
   }
   if (it == pending_cache_requests_.end()) {
     DLOG(ERROR) << "Could not find pending request for reply";
   } else {
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(&TrackedCallback::Run, it->second.callback, status));
     pending_cache_requests_.erase(it);
   }
   if (file == IPC::InvalidPlatformFileForTransit()) {
     DLOG(ERROR) << "Got invalid platformfilefortransit";
   } else if (status != PP_OK) {
     base::ClosePlatformFile(IPC::PlatformFileForTransitToPlatformFile(file));
   }
 }
 
 void PnaclTranslationResourceHost::CleanupCacheRequests() {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   for (CacheRequestInfoMap::iterator it = pending_cache_requests_.begin();
        it != pending_cache_requests_.end();
        ++it) {
     it->second.callback->PostAbort();
   }
   pending_cache_requests_.clear();
 }
 
+void PnaclTranslationResourceHost::EnsurePnaclInstalled(
+    PP_Instance instance,
+    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(PpapiGlobals::Get()->
+         GetMainThreadMessageLoop()->BelongsToCurrentThread());
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&PnaclTranslationResourceHost::SendEnsurePnaclInstalled,
+                 this, instance, callback));
+  return;
+}
+
+void PnaclTranslationResourceHost::SendEnsurePnaclInstalled(
+    PP_Instance instance,
+    scoped_refptr<TrackedCallback> callback) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  // If a request is already in, just queue this one and wait for notification.
+  // Hope that the request is not canceled.
+  if (pending_ensure_pnacl_requests_.size() > 0) {
+    pending_ensure_pnacl_requests_.push_back(callback);
+    return;
+  }
+  // Otherwise, try to send the request, then queue.
+  if (!channel_ || !channel_->Send(new NaClHostMsg_EnsurePnaclInstalled(
+          instance))) {
+    PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
+        FROM_HERE,
+        base::Bind(&TrackedCallback::Run,
+                   callback,
+                   static_cast<int32_t>(PP_ERROR_FAILED)));
+    return;
+  }
+  pending_ensure_pnacl_requests_.push_back(callback);
+}
+
+void PnaclTranslationResourceHost::OnEnsurePnaclInstalledReply(
+    PP_Instance instance,
+    bool success) {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  // Broadcast to all listeners.
+  for (EnsurePnaclInstalledList::iterator
+           i = pending_ensure_pnacl_requests_.begin(),
+           e = pending_ensure_pnacl_requests_.end();
+       i != e; ++i) {
+    if (TrackedCallback::IsPending(*i)) {
+      PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
+          FROM_HERE,
+          base::Bind(&TrackedCallback::Run,
+                     *i,
+                     static_cast<int32_t>(success ? PP_OK : PP_ERROR_FAILED)));
+    }
+  }
+  pending_ensure_pnacl_requests_.clear();
+}
+
+void PnaclTranslationResourceHost::OnEnsurePnaclInstalledProgress(

[jln (very slow on Chromium), 2013/08/05 23:58:28]

1. This is not a great way to do things as far as security is concerned, since
this new handler will completely bypass the IPC review process.

I don't particularly mind, especially since this is in a renderer. But keep in
mind that it's usually preferable to not create IPCs for future functions.

2. Could you check state here ? i.e. keep track of the state (the fact that
you've sent a query to the browser) somehow.

It's a good thing to catch attackers sending IPCs at an expected time. Again,
since this is in the renderer, it's not particularly important.

[jvoung (off chromium), 2013/08/06 01:11:13]

Ok, I'll take it out for now, and stub out earlier.  For (2), I could change the
'pending_ensure_pnacl_requests_' back from a vector to a map so that it could
check that the instance is actually in that map.  I'm not sure how hard it is to
guess the PP_Instance values though.

+    PP_Instance instance,
+    const nacl::PnaclInstallProgress& progress) {
+  // TODO(jvoung): Issue a progress event w/ dmichael's new DispatchEvent
+  // interface: https://codereview.chromium.org/14588009/
+}
+
+void PnaclTranslationResourceHost::CleanupEnsurePnaclRequests() {
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
+  for (EnsurePnaclInstalledList::iterator
+           i = pending_ensure_pnacl_requests_.begin(),
+           e = pending_ensure_pnacl_requests_.end();
+       i != e; ++i) {
+    (*i)->PostAbort();
+  }
+  pending_ensure_pnacl_requests_.clear();
+}
+
 #endif  // DISABLE_NACL