Remove nonsfi token workaround.

components/nacl/browser/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 "components/nacl/browser/nacl_file_host.h"
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 104 matching lines @@
     nacl_host_message_filter->Send(reply_msg);
   }
 }
 
 // Convert the file URL into a file descriptor.
 // This function is security sensitive.  Be sure to check with a security
 // person before you modify it.
 void DoOpenNaClExecutableOnThreadPool(
     scoped_refptr<nacl::NaClHostMessageFilter> nacl_host_message_filter,
     const GURL& file_url,
+    bool register_executable,

[Mark Seaborn, 2015/01/12 21:59:35]

How about calling this something like "enable_validation_caching"?

Understanding "register_executable" requires knowing more context of how this
part of validation caching works.

[teravest, 2015/01/13 16:47:34]

Done.

     IPC::Message* reply_msg) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   base::FilePath file_path;
   if (!nacl::NaClBrowser::GetDelegate()->MapUrlToLocalFilePath(
           file_url,
           true /* use_blocking_api */,
           nacl_host_message_filter->profile_directory(),
           &file_path)) {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 
   base::File file = nacl::OpenNaClReadExecImpl(file_path,
                                                true /* is_executable */);
   if (file.IsValid()) {
-    // This function is running on the blocking pool, but the path needs to be
-    // registered in a structure owned by the IO thread.
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(
-            &DoRegisterOpenedNaClExecutableFile,
-            nacl_host_message_filter,
-            Passed(file.Pass()), file_path, reply_msg,
-            static_cast<WriteFileInfoReply>(
-                NaClHostMsg_OpenNaClExecutable::WriteReplyParams)));
+    if (register_executable) {

[Mark Seaborn, 2015/01/12 21:59:34]

Can you add a comment to explain that: Both branches of this conditional will
behave correctly but have different performance trade-offs.  One registers the
FD for use with validation caching.  Registering the FD carries a small up-front
penalty but saves time later -- but that penalty isn't wanted in Non-SFI Mode
which doesn't need validation caching.

Without the explanation, this code is rather obscure. :-)

[teravest, 2015/01/13 16:47:34]

Good point. I've added a comment here.

+      // This function is running on the blocking pool, but the path needs to be
+      // registered in a structure owned by the IO thread.
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(
+              &DoRegisterOpenedNaClExecutableFile,
+              nacl_host_message_filter,
+              Passed(file.Pass()), file_path, reply_msg,
+              static_cast<WriteFileInfoReply>(
+                  NaClHostMsg_OpenNaClExecutable::WriteReplyParams)));
+    } else {
+      IPC::PlatformFileForTransit file_desc =
+          IPC::TakeFileHandleForProcess(file.Pass(),
+                                        nacl_host_message_filter->PeerHandle());
+      uint64_t dummy_file_token = 0;
+      NaClHostMsg_OpenNaClExecutable::WriteReplyParams(
+          reply_msg, file_desc, dummy_file_token, dummy_file_token);
+      nacl_host_message_filter->Send(reply_msg);
+    }
   } else {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 }
 
 }  // namespace
 
 namespace nacl_file_host {
 
@@ skipping 43 matching lines @@
   base::FilePath full_path = pnacl_dir.AppendASCII(
       std::string(kExpectedFilePrefix) + filename);
   *file_to_open = full_path;
   return true;
 }
 
 void OpenNaClExecutable(
     scoped_refptr<nacl::NaClHostMessageFilter> nacl_host_message_filter,
     int render_view_id,
     const GURL& file_url,
+    bool register_executable,
     IPC::Message* reply_msg) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &OpenNaClExecutable,
             nacl_host_message_filter,
-            render_view_id, file_url, reply_msg));
+            render_view_id,
+            file_url,
+            register_executable,
+            reply_msg));
     return;
   }
 
   // Make sure render_view_id is valid and that the URL is a part of the
   // render view's site. Without these checks, apps could probe the extension
   // directory or run NaCl code from other extensions.
   content::RenderViewHost* rvh = content::RenderViewHost::FromID(
       nacl_host_message_filter->render_process_id(), render_view_id);
   if (!rvh) {
     nacl_host_message_filter->BadMessageReceived();  // Kill the renderer.
     return;
   }
   content::SiteInstance* site_instance = rvh->GetSiteInstance();
   if (!content::SiteInstance::IsSameWebSite(site_instance->GetBrowserContext(),
                                             site_instance->GetSiteURL(),
                                             file_url)) {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 
   // The URL is part of the current app. Now query the extension system for the
   // file path and convert that to a file descriptor. This should be done on a
   // blocking pool thread.
   if (!BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(
           &DoOpenNaClExecutableOnThreadPool,
           nacl_host_message_filter,
-          file_url, reply_msg))) {
+          file_url,
+          register_executable,
+          reply_msg))) {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
   }
 }
 
 }  // namespace nacl_file_host