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

chrome/browser/nacl_host/nacl_file_host.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.
 
 #include "chrome/browser/nacl_host/nacl_file_host.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
@@ skipping 25 matching lines @@
 // in file name limit error-handling-code-paths, etc.
 const size_t kMaxFileLength = 40;
 
 void NotifyRendererOfError(
     NaClHostMessageFilter* nacl_host_message_filter,
     IPC::Message* reply_msg) {
   reply_msg->set_reply_error();
   nacl_host_message_filter->Send(reply_msg);
 }
 
+void ReplyEnsurePnaclInstalledOnIOThread(
+    const nacl_file_host::InstallCallback& cb,
+    bool success) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  cb.Run(success);
+}
+
+void PnaclCheckDone(
+    const nacl_file_host::InstallCallback& done_callback,
+    const nacl_file_host::InstallProgressCallback& progress_callback,
+    bool success) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ReplyEnsurePnaclInstalledOnIOThread,
+                 done_callback, success));
+}
+
+void TryInstallPnacl(
+    const nacl_file_host::InstallCallback& done_callback,
+    const nacl_file_host::InstallProgressCallback& progress_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  NaClBrowser::GetDelegate()->TryInstallPnacl(
+      base::Bind(&PnaclCheckDone,
+                 done_callback,
+                 progress_callback));
+}
+
+void SendNotInstalledProgress(
+    const nacl_file_host::InstallCallback& done_callback,
+    const nacl_file_host::InstallProgressCallback& progress_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  progress_callback.Run(0, -1);
+  // TryInstall after sending the progress event so that they are more ordered.
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&TryInstallPnacl, done_callback, progress_callback));
+}
+
+void DoEnsurePnaclInstalled(
+    const nacl_file_host::InstallCallback& done_callback,
+    const nacl_file_host::InstallProgressCallback& progress_callback) {

[Derek Schuff, 2013/07/23 21:39:29]

maybe DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());

[jvoung (off chromium), 2013/07/31 21:41:07]

Done.

+  // If already installed, return on IO thread.
+  base::FilePath pnacl_dir;
+  if (NaClBrowser::GetDelegate()->GetPnaclDirectory(&pnacl_dir) &&

[Derek Schuff, 2013/07/23 21:39:29]

actually, I think we may have to call NaClBrowser on the IO thread... although
it's probably ok as long as we ensure that the instance already exists, since
neither NaClBrowser nor the delegate should change... Does GetPnaclDirectory
have to be on the UI thread or a blocking thread, or does it matter?

[jvoung (off chromium), 2013/07/31 21:41:07]

NaClBrowser does get called in during early browser startup and that's when
SetDelegate() is done in the non-testing cases.  After that it's not set
anymore.  Not sure if that's early enough.
The the non-test GetPnaclDirectory() implementation uses PathService.  That
claims to be safe to call from multiple threads and uses locks.

+      base::PathExists(pnacl_dir)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&ReplyEnsurePnaclInstalledOnIOThread,
+                   done_callback, true));
+    return;
+  }
+
+  // Otherwise, request an install (but send some "unknown" progress first).
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&SendNotInstalledProgress, done_callback, progress_callback));
+}
+
 bool PnaclDoOpenFile(const base::FilePath& file_to_open,
                      base::PlatformFile* out_file) {
   base::PlatformFileError error_code;
   *out_file = base::CreatePlatformFile(file_to_open,
                                        base::PLATFORM_FILE_OPEN |
                                        base::PLATFORM_FILE_READ,
                                        NULL,
                                        &error_code);
   if (error_code != base::PLATFORM_FILE_OK) {
     return false;
   }
   return true;
 }
 
 void DoOpenPnaclFile(
     scoped_refptr<NaClHostMessageFilter> nacl_host_message_filter,
     const std::string& filename,
-    IPC::Message* reply_msg);
-
-void PnaclCheckDone(
-    scoped_refptr<NaClHostMessageFilter> nacl_host_message_filter,
-    const std::string& filename,
-    IPC::Message* reply_msg,
-    bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!success) {
-    NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
-  } else {
-    if (!BrowserThread::PostBlockingPoolTask(
-            FROM_HERE,
-            base::Bind(&DoOpenPnaclFile,
-                       nacl_host_message_filter,
-                       filename,
-                       reply_msg))) {
-      NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
-    }
-  }
-}
-
-void TryInstallPnacl(
-    scoped_refptr<NaClHostMessageFilter> nacl_host_message_filter,
-    const std::string& filename,
-    IPC::Message* reply_msg) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ComponentUpdateService* cus = g_browser_process->component_updater();
-  PnaclComponentInstaller* pci =
-      g_browser_process->pnacl_component_installer();
-  RequestFirstInstall(cus,
-                      pci,
-                      base::Bind(&PnaclCheckDone,
-                                 nacl_host_message_filter,
-                                 filename,
-                                 reply_msg));
-}
-
-void DoOpenPnaclFile(
-    scoped_refptr<NaClHostMessageFilter> nacl_host_message_filter,
-    const std::string& filename,
     IPC::Message* reply_msg) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::FilePath full_filepath;
 
   // PNaCl must be installed.
   base::FilePath pnacl_dir;
   if (!NaClBrowser::GetDelegate()->GetPnaclDirectory(&pnacl_dir) ||
       !base::PathExists(pnacl_dir)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&TryInstallPnacl,
-                   nacl_host_message_filter,
-                   filename,
-                   reply_msg));
+    NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 
   // Do some validation.
   if (!nacl_file_host::PnaclCanOpenFile(filename, &full_filepath)) {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 
   base::PlatformFile file_to_open;
@@ skipping 119 matching lines @@
   } else {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 }
 
 }  // namespace
 
 namespace nacl_file_host {
 
+void EnsurePnaclInstalled(
+    const InstallCallback& done_callback,
+    const InstallProgressCallback& progress_callback) {
+  if (!BrowserThread::PostBlockingPoolTask(
+          FROM_HERE,
+          base::Bind(&DoEnsurePnaclInstalled,
+                     done_callback,
+                     progress_callback))) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    done_callback.Run(false);
+  }
+}
+
 void GetReadonlyPnaclFd(
     scoped_refptr<NaClHostMessageFilter> nacl_host_message_filter,
     const std::string& filename,
     IPC::Message* reply_msg) {
   if (!BrowserThread::PostBlockingPoolTask(
           FROM_HERE,
           base::Bind(&DoOpenPnaclFile,
                      nacl_host_message_filter,
                      filename,
                      reply_msg))) {
@@ skipping 76 matching lines @@
       base::Bind(
           &DoOpenNaClExecutableOnThreadPool,
           nacl_host_message_filter,
           extension_info_map,
           file_url, reply_msg))) {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
   }
 }
 
 }  // namespace nacl_file_host