NaCl: Stop sending resource FDs with NaClProcessMsg_Start

components/nacl/loader/nacl_listener.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/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 188 matching lines @@
 
 
 NaClListener::NaClListener() : shutdown_event_(true, false),
                                io_thread_("NaCl_IOThread"),
 #if defined(OS_LINUX)
                                prereserved_sandbox_size_(0),
 #endif
 #if defined(OS_POSIX)
                                number_of_cores_(-1),  // unknown/error
 #endif
-                               main_loop_(NULL) {
+                               main_loop_(NULL),
+                               is_started_(false) {
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
   DCHECK(g_listener == NULL);
   g_listener = this;
 }
 
 NaClListener::~NaClListener() {
   NOTREACHED();
   shutdown_event_.Signal();
   g_listener = NULL;
@@ skipping 48 matching lines @@
   channel_->AddFilter(filter_.get());
   channel_->AddFilter(new FileTokenMessageFilter());
   channel_->Init(channel_name, IPC::Channel::MODE_CLIENT, true);
   main_loop_ = base::MessageLoop::current();
   main_loop_->Run();
 }
 
 bool NaClListener::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(NaClListener, msg)
+      IPC_MESSAGE_HANDLER(NaClProcessMsg_AddPrefetchedResource,
+                          OnAddPrefetchedResource)
       IPC_MESSAGE_HANDLER(NaClProcessMsg_Start, OnStart)
       IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool NaClListener::OnOpenResource(
     const IPC::Message& msg,
     const std::string& key,
     NaClIPCAdapter::OpenResourceReplyCallback cb) {
@@ skipping 12 matching lines @@
     // and return true.
     cb.Run(msg, file, path);
     return true;
   }
 
   // Return false to fall back to the slow path. Let NaClIPCAdapter issue an
   // IPC to the renderer.
   return false;
 }
 
+void NaClListener::OnAddPrefetchedResource(
+    const nacl::NaClResourcePrefetchResult& prefetched_resource_file) {
+  DCHECK(!is_started_);
+  if (is_started_)
+    return;
+  bool result = prefetched_resource_files_.insert(std::make_pair(
+      prefetched_resource_file.file_key,
+      std::make_pair(
+          prefetched_resource_file.file,
+          prefetched_resource_file.file_path_metadata))).second;
+  if (!result) {
+    LOG(FATAL) << "Duplicated open_resource key: "
+               << prefetched_resource_file.file_key;
+  }
+}
+
 void NaClListener::OnStart(const nacl::NaClStartParams& params) {
+  is_started_ = true;
 #if defined(OS_LINUX) || defined(OS_MACOSX)
   int urandom_fd = dup(base::GetUrandomFD());
   if (urandom_fd < 0) {
     LOG(ERROR) << "Failed to dup() the urandom FD";
     return;
   }
   NaClChromeMainSetUrandomFd(urandom_fd);
 #endif
   struct NaClApp* nap = NULL;
   NaClChromeMainInit();
 
   CHECK(base::SharedMemory::IsHandleValid(params.crash_info_shmem_handle));
   crash_info_shmem_.reset(new base::SharedMemory(
       params.crash_info_shmem_handle, false /* not readonly */));
   CHECK(crash_info_shmem_->Map(nacl::kNaClCrashInfoShmemSize));
   NaClSetFatalErrorCallback(&FatalLogHandler);
 
   nap = NaClAppCreate();
   if (nap == NULL) {
     LOG(ERROR) << "NaClAppCreate() failed";
     return;
   }
 
   IPC::ChannelHandle browser_handle;
   IPC::ChannelHandle ppapi_renderer_handle;
   IPC::ChannelHandle manifest_service_handle;
 
-  for (size_t i = 0; i < params.prefetched_resource_files.size(); ++i) {
-    bool result = prefetched_resource_files_.insert(std::make_pair(
-        params.prefetched_resource_files[i].file_key,
-        std::make_pair(
-            params.prefetched_resource_files[i].file,
-            params.prefetched_resource_files[i].file_path_metadata))).second;
-    if (!result) {
-      LOG(FATAL) << "Duplicated open_resource key: "
-                 << params.prefetched_resource_files[i].file_key;
-    }
-  }
-
   if (params.enable_ipc_proxy) {
     browser_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     ppapi_renderer_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     manifest_service_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
 
     // Create the PPAPI IPC channels between the NaCl IRT and the host
     // (browser/renderer) processes. The IRT uses these channels to
     // communicate with the host and to initialize the IPC dispatchers.
     SetUpIPCAdapter(&browser_handle, io_thread_.message_loop_proxy(),
                     nap, NACL_CHROME_DESC_BASE,
@@ skipping 139 matching lines @@
 }
 
 void NaClListener::OnFileTokenResolved(
     uint64_t token_lo,
     uint64_t token_hi,
     IPC::PlatformFileForTransit ipc_fd,
     base::FilePath file_path) {
   resolved_cb_.Run(ipc_fd, file_path);
   resolved_cb_.Reset();
 }