Non-SFI NaCl: Batch-open resource files

components/nacl/renderer/ppb_nacl_private_impl.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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_nonsfi_util.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/nacl/common/nacl_types.h"
 #include "components/nacl/renderer/file_downloader.h"
 #include "components/nacl/renderer/histogram.h"
@@ skipping 28 matching lines @@
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebURLLoaderOptions.h"
 #include "third_party/jsoncpp/source/include/json/reader.h"
 #include "third_party/jsoncpp/source/include/json/value.h"
 
+#if defined(OS_POSIX)
+#include "ipc/file_descriptor_set_posix.h"
+#endif
+
 namespace nacl {
 namespace {
 
 // The pseudo-architecture used to indicate portable native client.
 const char* const kPortableArch = "portable";
 
 // The base URL for resources used by the PNaCl translator processes.
 const char* kPNaClTranslatorBaseUrl = "chrome://pnacl-translator/";
 
+// The maximum number of resource files DownloadNexe() can open.
+const size_t kMaxPreOpenResourceFiles = 121;
+
+#if defined(OS_POSIX)
+// On POSIX platforms, the maximum number of files a process can pass to
+// another is limited to kMaxDescriptorsPerMessage which is 128. Since
+// the browser process may use up to 7 descriptors for passing non-resource
+// files when creating the NaCl plugin process, kMaxPreOpenResourceFiles
+// must be smaller than or equal to 121.
+COMPILE_ASSERT(kMaxPreOpenResourceFiles <=
+               FileDescriptorSet::kMaxDescriptorsPerMessage - 7,
+               k_max_pre_open_resource_files_too_large);
+#endif
+
 base::LazyInstance<scoped_refptr<PnaclTranslationResourceHost> >
     g_pnacl_resource_host = LAZY_INSTANCE_INITIALIZER;
 
 bool InitializePnaclResourceHost() {
   // Must run on the main thread.
   content::RenderThread* render_thread = content::RenderThread::Get();
   if (!render_thread)
     return false;
   if (!g_pnacl_resource_host.Get().get()) {
     g_pnacl_resource_host.Get() = new PnaclTranslationResourceHost(
@@ skipping 209 matching lines @@
   DCHECK(pp_process_type > PP_UNKNOWN_NACL_PROCESS_TYPE &&
          pp_process_type < PP_NUM_NACL_PROCESS_TYPES);
   return static_cast<NaClAppProcessType>(pp_process_type);
 }
 
 // Launch NaCl's sel_ldr process.
 void LaunchSelLdr(PP_Instance instance,
                   PP_Bool main_service_runtime,
                   const char* alleged_url,
                   const PP_NaClFileInfo* nexe_file_info,
+                  const PP_NaClResourceFileHandle* resource_file_handles,
+                  uint32_t resource_file_handles_len,
                   PP_Bool uses_nonsfi_mode,
                   PP_Bool enable_ppapi_dev,
                   PP_NaClAppProcessType pp_process_type,
                   void* imc_handle,
                   PP_CompletionCallback callback) {
   CHECK(ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->
             BelongsToCurrentThread());
   NaClAppProcessType process_type = PP_ToNaClAppProcessType(pp_process_type);
   // Create the manifest service proxy here, so on error case, it will be
   // destructed (without passing it to ManifestServiceChannel).
@@ skipping 33 matching lines @@
   // must also check on the trusted side of the proxy.
   if (enable_ppapi_dev)
     perm_bits |= ppapi::PERMISSION_DEV;
   instance_info.permissions =
       ppapi::PpapiPermissions::GetForCommandLine(perm_bits);
   std::string error_message_string;
   NaClLaunchResult launch_result;
 
   IPC::PlatformFileForTransit nexe_for_transit =
       IPC::InvalidPlatformFileForTransit();
+  std::vector<NaClLaunchParams::ResourceFileInfo> resource_files_info;
+
 #if defined(OS_POSIX)
   if (nexe_file_info->handle != PP_kInvalidFileHandle)
     nexe_for_transit = base::FileDescriptor(nexe_file_info->handle, true);
+  for (size_t i = 0; i < resource_file_handles_len; ++i) {
+    NaClLaunchParams::ResourceFileInfo resource_file_info(
+        base::FileDescriptor(resource_file_handles[i].handle, true),
+        resource_file_handles[i].token_lo,
+        resource_file_handles[i].token_hi,
+        resource_file_handles[i].key);
+    resource_files_info.push_back(resource_file_info);
+  }
 #elif defined(OS_WIN)
   // Duplicate the handle on the browser side instead of the renderer.
   // This is because BrokerGetFileForProcess isn't part of content/public, and
   // it's simpler to do the duplication in the browser anyway.
   nexe_for_transit = nexe_file_info->handle;
+  // TODO(yusukes): Support pre-opening resource files.
+  CHECK(resource_file_handles_len == 0);
 #else
 #error Unsupported target platform.
 #endif
   if (!sender->Send(new NaClHostMsg_LaunchNaCl(
           NaClLaunchParams(
               instance_info.url.spec(),
               nexe_for_transit,
               nexe_file_info->token_lo,
               nexe_file_info->token_hi,
+              resource_files_info,
               routing_id,
               perm_bits,
               PP_ToBool(uses_nonsfi_mode),
               process_type),
           &launch_result,
           &error_message_string))) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
@@ skipping 290 matching lines @@
     }
   }
 
   // If the resource host isn't initialized, don't try to do that here.
   // Just return because something is already very wrong.
   if (g_pnacl_resource_host.Get().get() == NULL)
     return;
   g_pnacl_resource_host.Get()->ReportTranslationFinished(instance, success);
 }
 
-PP_FileHandle OpenNaClExecutable(PP_Instance instance,
-                                 const char* file_url,
-                                 uint64_t* nonce_lo,
-                                 uint64_t* nonce_hi) {
+PP_FileHandle OpenNaClResources(
+    PP_Instance instance,
+    const char* file_url,
+    uint64_t* nonce_lo,
+    uint64_t* nonce_hi,
+    const std::vector<std::string>& resource_file_urls,
+    PP_NaClResourceFileHandle** out_resource_file_handles,
+    uint32_t* out_resource_file_handles_len) {
   // Fast path only works for installed file URLs.
   GURL gurl(file_url);
   if (!gurl.SchemeIs("chrome-extension"))
     return PP_kInvalidFileHandle;
 
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance)
     return PP_kInvalidFileHandle;
   // IMPORTANT: Make sure the document can request the given URL. If we don't
   // check, a malicious app could probe the extension system. This enforces a
   // same-origin policy which prevents the app from requesting resources from
   // another app.
   blink::WebSecurityOrigin security_origin =
       plugin_instance->GetContainer()->element().document().securityOrigin();
   if (!security_origin.canRequest(gurl))
     return PP_kInvalidFileHandle;
 
   IPC::PlatformFileForTransit out_fd = IPC::InvalidPlatformFileForTransit();
   IPC::Sender* sender = content::RenderThread::Get();
   DCHECK(sender);
   *nonce_lo = 0;
   *nonce_hi = 0;
   base::FilePath file_path;
-  if (!sender->Send(
-      new NaClHostMsg_OpenNaClExecutable(GetRoutingID(instance),
-                                         GURL(file_url),
-                                         &out_fd,
-                                         nonce_lo,
-                                         nonce_hi))) {
+
+  std::vector<GURL> resource_urls;
+  for (size_t i = 0; i < resource_file_urls.size(); ++i) {
+    GURL gurl(resource_file_urls[i]);
+    if (!gurl.SchemeIs("chrome-extension"))
+      return PP_kInvalidFileHandle;
+    if (!security_origin.canRequest(gurl))
+      return PP_kInvalidFileHandle;
+    resource_urls.push_back(gurl);
+  }
+
+  nacl::NaClOpenExecutableResult open_result;
+  if (!sender->Send(new NaClHostMsg_OpenNaClResources(GetRoutingID(instance),
+                                                      GURL(file_url),
+                                                      resource_urls,
+                                                      &open_result))) {
     return PP_kInvalidFileHandle;
   }
 
-  if (out_fd == IPC::InvalidPlatformFileForTransit())
+  if (open_result.file_info.file == IPC::InvalidPlatformFileForTransit())
     return PP_kInvalidFileHandle;
 
+  for (size_t i = 0; i < open_result.resource_files_info.size(); ++i) {
+    if (open_result.resource_files_info[i].file ==
+        IPC::InvalidPlatformFileForTransit()) {
+      DLOG(ERROR) << "Could not open a resource file: "
+                  << resource_file_urls[i];
+      return PP_kInvalidFileHandle;
+    }
+  }
+
+  out_fd = open_result.file_info.file;
+  *nonce_lo = open_result.file_info.file_token_lo;
+  *nonce_hi = open_result.file_info.file_token_hi;
+
+  if (out_resource_file_handles && !open_result.resource_files_info.empty()) {
+    DCHECK(out_resource_file_handles_len);
+    *out_resource_file_handles_len =
+        static_cast<uint32_t>(open_result.resource_files_info.size());
+    *out_resource_file_handles =
+        new PP_NaClResourceFileHandle[*out_resource_file_handles_len];
+    for (size_t i = 0; i < *out_resource_file_handles_len; ++i) {
+      PP_NaClResourceFileHandle& entry = (*out_resource_file_handles)[i];
+      entry.handle = IPC::PlatformFileForTransitToPlatformFile(
+          open_result.resource_files_info[i].file);
+      entry.token_lo = open_result.resource_files_info[i].file_token_lo;
+      entry.token_hi = open_result.resource_files_info[i].file_token_hi;
+      entry.key = NULL;  // DownloadNexe fills this later.
+    }
+  }
+
   return IPC::PlatformFileForTransitToPlatformFile(out_fd);
 }
 
 void DispatchEvent(PP_Instance instance,
                    PP_NaClEventType event_type,
                    const char *resource_url,
                    PP_Bool length_is_computable,
                    uint64_t loaded_bytes,
                    uint64_t total_bytes) {
   ProgressEvent event(event_type,
@@ skipping 473 matching lines @@
 };
 
 void DownloadNexeCompletion(const DownloadNexeRequest& request,
                             PP_NaClFileInfo* out_file_info,
                             FileDownloader::Status status,
                             base::File target_file,
                             int http_status);
 
 void DownloadNexe(PP_Instance instance,
                   const char* url,
+                  PP_Bool download_resource_files,
                   PP_NaClFileInfo* out_file_info,
+                  PP_NaClResourceFileHandle** out_resource_file_handles,
+                  uint32_t* out_resource_file_handles_len,
                   PP_CompletionCallback callback) {
   CHECK(url);
   CHECK(out_file_info);
+  CHECK(!download_resource_files || out_resource_file_handles);
+
   DownloadNexeRequest request;
   request.instance = instance;
   request.url = url;
   request.callback = callback;
   request.start_time = base::Time::Now();
 
+  std::vector<
+    std::pair<std::string /*url*/, std::string /*key*/> > resource_files;
+  std::vector<std::string> resource_file_urls;
+
+  if (download_resource_files) {
+    JsonManifest* manifest = GetJsonManifest(instance);
+    if (manifest)
+      manifest->GetFiles(&resource_files);
+    if (resource_files.size() > kMaxPreOpenResourceFiles)
+      resource_files.resize(kMaxPreOpenResourceFiles);
+    for (size_t i = 0; i < resource_files.size(); ++i) {
+      resource_file_urls.push_back(resource_files[i].first);
+    }
+  }
+
   // Try the fast path for retrieving the file first.
-  PP_FileHandle handle = OpenNaClExecutable(instance,
-                                            url,
-                                            &out_file_info->token_lo,
-                                            &out_file_info->token_hi);
+  PP_FileHandle handle = OpenNaClResources(instance,
+                                           url,
+                                           &out_file_info->token_lo,
+                                           &out_file_info->token_hi,
+                                           resource_file_urls,
+                                           out_resource_file_handles,
+                                           out_resource_file_handles_len);
   if (handle != PP_kInvalidFileHandle) {
+    if (!resource_files.empty()) {
+      for (size_t i = 0; i < resource_files.size(); ++i) {
+        PP_NaClResourceFileHandle& entry = (*out_resource_file_handles)[i];

[teravest, 2014/11/10 20:36:12]

Please use a pointer instead of a reference here.

[Yusuke Sato, 2014/11/11 00:58:35]

Done.

+        CHECK(entry.handle != PP_kInvalidFileHandle) << i;
+        entry.key = strdup(resource_files[i].second.c_str());
+      }
+    }
     DownloadNexeCompletion(request,
                            out_file_info,
                            FileDownloader::SUCCESS,
                            base::File(handle),
                            200);
     return;
   }
 
   // The fast path didn't work, we'll fetch the file using URLLoader and write
   // it to local storage.
   base::File target_file(CreateTemporaryFile(instance));
   GURL gurl(url);
 
+  // On the slow path, do not retry to pre-open the resource files.
+  if (out_resource_file_handles)
+    *out_resource_file_handles = NULL;
+
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
@@ skipping 117 matching lines @@
         FROM_HERE,
         base::Bind(callback,
                    static_cast<int32_t>(PP_ERROR_FAILED),
                    kInvalidNaClFileInfo));
     return;
   }
 
   // Try the fast path for retrieving the file first.
   uint64_t file_token_lo = 0;
   uint64_t file_token_hi = 0;
-  PP_FileHandle file_handle = OpenNaClExecutable(instance,
-                                                 url.c_str(),
-                                                 &file_token_lo,
-                                                 &file_token_hi);
+  PP_FileHandle file_handle = OpenNaClResources(instance,
+                                                url.c_str(),
+                                                &file_token_lo,
+                                                &file_token_hi,
+                                                std::vector<std::string>(),
+                                                NULL,
+                                                NULL);
   if (file_handle != PP_kInvalidFileHandle) {
     PP_NaClFileInfo file_info;
     file_info.handle = file_handle;
     file_info.token_lo = file_token_lo;
     file_info.token_hi = file_token_hi;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, static_cast<int32_t>(PP_OK), file_info));
     return;
   }
@@ skipping 301 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl