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

chrome/renderer/pepper/pnacl_translation_resource_host.h

 // 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.
 
 #ifndef CHROME_RENDERER_PEPPER_PNACL_TRANSLATION_RESOURCE_HOST_H_
 #define CHROME_RENDERER_PEPPER_PNACL_TRANSLATION_RESOURCE_HOST_H_
 
 #include <map>
 
+#include "base/basictypes.h"
 #include "components/nacl/common/pnacl_types.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_platform_file.h"
 #include "ppapi/c/private/pp_file_handle.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 
 // A class to keep track of requests made to the browser for resources that the
 // PNaCl translator needs (e.g. descriptors for the translator nexes, temp
 // files, and cached translations).
 
 // "Resource" might not be the best name for the various things that pnacl
 // needs from the browser since "Resource" is a Pepper thing...
 class PnaclTranslationResourceHost : public IPC::ChannelProxy::MessageFilter {
  public:
   explicit PnaclTranslationResourceHost(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
   void RequestNexeFd(int render_view_id,
                      PP_Instance instance,
                      const nacl::PnaclCacheInfo& cache_info,
                      PP_Bool* is_hit,
                      PP_FileHandle* file_handle,
                      scoped_refptr<ppapi::TrackedCallback> callback);
   void ReportTranslationFinished(PP_Instance instance);
 
+  // Ensure that PNaCl resources (pnacl-llc.nexe, linker, libs) are installed.
+  void EnsurePnaclInstalled(PP_Instance instance,
+                            scoped_refptr<ppapi::TrackedCallback> callback);
+
  protected:
   virtual ~PnaclTranslationResourceHost();
 
  private:
   class CacheRequestInfo {
    public:
     CacheRequestInfo(PP_Bool* hit,
                      PP_FileHandle* handle,
                      scoped_refptr<ppapi::TrackedCallback> cb);
 
     ~CacheRequestInfo();
 
     PP_Bool* is_hit;
     PP_FileHandle* file_handle;
     scoped_refptr<ppapi::TrackedCallback> callback;
   };
 
   // Maps the instance with an outstanding cache request to the info
   // about that request.
   typedef std::map<PP_Instance, CacheRequestInfo> CacheRequestInfoMap;
+  // Maps the instance to an outstanding ensure pnacl installed request.

[dmichael (off chromium), 2013/08/01 17:33:49]

s/ensure pnacl installed/EnsurePnaclInstalled
might read better.

[jvoung (off chromium), 2013/08/01 23:14:07]

Done.

+  typedef std::map<PP_Instance, scoped_refptr<ppapi::TrackedCallback> >
+      EnsurePnaclInstalledMap;

[dmichael (off chromium), 2013/08/01 17:37:00]

By the way... what happens if a particular plugin calls EnsurePnaclInstalledMap?
I presume it shouldn't happen, but it would be good to handle that in some way.

[jvoung (off chromium), 2013/08/01 23:14:07]

It could actually happen, if you load multiple PNaCl embeds at once.  It does
get a bit confusing if you allow all of them to proceed downstream and actually
try to install, because the code downstream rate-limits.  The second request
gets rejected.

I've changed the code to only send one request and queue the rest, and changed
the reply to broadcast the result to all queued requests.  That should be "okay"
for normal use.  It could be bad if an install was actually necessary, but the
first requester stops running.  Then the rest would be waiting indefinitely.

   // IPC::ChannelProxy::MessageFilter implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE;
   virtual void OnFilterRemoved() OVERRIDE;
   virtual void OnChannelClosing() OVERRIDE;
 
   void OnNexeTempFileReply(PP_Instance instance,
                            bool is_hit,
                            IPC::PlatformFileForTransit file);
   void CleanupCacheRequests();
+  void OnEnsurePnaclInstalledReply(PP_Instance instance,
+                                   bool success);
+  void OnEnsurePnaclInstalledProgress(PP_Instance instance,
+                                      int64 current_progress,
+                                      int64 total);
+  void CleanupEnsurePnaclRequests();
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   IPC::Channel* channel_;

[dmichael (off chromium), 2013/08/01 17:33:49]

^^^ it looks like channel_ should also only be accessed on the io thread.

[jvoung (off chromium), 2013/08/01 23:14:07]

Yes, I'll put it under the comment as well.

 
   // Should be accessed on the io thread.
   CacheRequestInfoMap pending_cache_requests_;
+  EnsurePnaclInstalledMap pending_ensure_pnacl_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(PnaclTranslationResourceHost);
 };
 
 #endif  // CHROME_RENDERER_PEPPER_PNACL_TRANSLATION_RESOURCE_HOST_H_