Use sequenced blocking pool task to create PNaCl's nexe temp file

chrome/browser/nacl_host/pnacl_host.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 "chrome/browser/nacl_host/pnacl_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 95 matching lines @@
   disk_cache_->InitCache(
       temp_dir,
       true,  // Use in-memory backend
       base::Bind(&PnaclHost::OnCacheInitialized, weak_factory_.GetWeakPtr()));
 }
 
 ///////////////////////////////////////// Temp files
 
 // Create a temporary file on the blocking pool
 // static
-base::PlatformFile PnaclHost::DoCreateTemporaryFile(base::FilePath temp_dir) {
+void PnaclHost::DoCreateTemporaryFile(base::FilePath temp_dir,
+                                      TempFileCallback cb) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   base::FilePath file_path;
+  base::PlatformFile file_handle(base::kInvalidPlatformFileValue);
   bool rv = temp_dir.empty()
                 ? file_util::CreateTemporaryFile(&file_path)
                 : file_util::CreateTemporaryFileInDir(temp_dir, &file_path);
   if (!rv) {
     PLOG(ERROR) << "Temp file creation failed.";
-    return base::kInvalidPlatformFileValue;
+  } else {
+    base::PlatformFileError error;
+    file_handle = base::CreatePlatformFile(
+        file_path,
+        base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_READ |
+            base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_TEMPORARY |
+            base::PLATFORM_FILE_DELETE_ON_CLOSE,
+        NULL,
+        &error);
+
+    if (error != base::PLATFORM_FILE_OK) {
+      PLOG(ERROR) << "Temp file open failed: " << error;
+      file_handle = base::kInvalidPlatformFileValue;
+    }
   }
-  base::PlatformFileError error;
-  base::PlatformFile file_handle(base::CreatePlatformFile(
-      file_path,
-      base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_READ |
-          base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_TEMPORARY |
-          base::PLATFORM_FILE_DELETE_ON_CLOSE,
-      NULL,
-      &error));
-
-  if (error != base::PLATFORM_FILE_OK) {
-    PLOG(ERROR) << "Temp file open failed: " << error;
-    return base::kInvalidPlatformFileValue;
-  }
-
-  return file_handle;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE, base::Bind(cb, file_handle));
 }
 
 void PnaclHost::CreateTemporaryFile(TempFileCallback cb) {
-  if (!base::PostTaskAndReplyWithResult(
-          BrowserThread::GetBlockingPool(),
-          FROM_HERE,
-          base::Bind(&PnaclHost::DoCreateTemporaryFile, temp_dir_),
-          cb)) {
+  if (!BrowserThread::PostBlockingPoolSequencedTask(
+           "PnaclHostCreateTempFile",
+           FROM_HERE,
+           base::Bind(&PnaclHost::DoCreateTemporaryFile, temp_dir_, cb))) {
     DCHECK(thread_checker_.CalledOnValidThread());
     cb.Run(base::kInvalidPlatformFileValue);
   }
 }
 
 ///////////////////////////////////////// GetNexeFd implementation
 ////////////////////// Common steps
 
 void PnaclHost::GetNexeFd(int render_process_id,
                           int render_view_id,
@@ skipping 144 matching lines @@
           it->second.got_cache_reply &&
           it->second.got_nexe_fd) {
         return;
       }
     }
     ReturnMiss(entry);
     return;
   }
 
   if (!base::PostTaskAndReplyWithResult(
-          BrowserThread::GetBlockingPool(),
-          FROM_HERE,
-          base::Bind(
-              &PnaclHost::CopyBufferToFile, pt->nexe_fd, pt->nexe_read_buffer),
-          base::Bind(&PnaclHost::OnBufferCopiedToTempFile,
-                     weak_factory_.GetWeakPtr(),
-                     entry->first))) {
+           BrowserThread::GetBlockingPool(),
+           FROM_HERE,
+           base::Bind(
+               &PnaclHost::CopyBufferToFile, pt->nexe_fd, pt->nexe_read_buffer),
+           base::Bind(&PnaclHost::OnBufferCopiedToTempFile,
+                      weak_factory_.GetWeakPtr(),
+                      entry->first))) {
     pt->callback.Run(base::kInvalidPlatformFileValue, false);
   }
 }
 
 //////////////////// GetNexeFd miss path
 // Return the temp fd to the renderer, reporting a miss.
 void PnaclHost::ReturnMiss(const PendingTranslationMap::iterator& entry) {
   // Return the fd
   PendingTranslation* pt = &entry->second;
   NexeFdCallback cb(pt->callback);
@@ skipping 48 matching lines @@
   bool store_nexe = true;
   // If this is a premature response (i.e. we haven't returned a temp file
   // yet) or if it's an unsuccessful translation, or if we are incognito,
   // don't store in the cache.
   // TODO(dschuff): use a separate in-memory cache for incognito
   // translations.
   if (!entry->second.got_nexe_fd || !entry->second.got_cache_reply ||
       !success || entry->second.is_incognito) {
     store_nexe = false;
   } else if (!base::PostTaskAndReplyWithResult(
-                 BrowserThread::GetBlockingPool(),
-                 FROM_HERE,
-                 base::Bind(&PnaclHost::CopyFileToBuffer,
-                            entry->second.nexe_fd),
-                 base::Bind(&PnaclHost::StoreTranslatedNexe,
-                            weak_factory_.GetWeakPtr(),
-                            id))) {
+                  BrowserThread::GetBlockingPool(),
+                  FROM_HERE,
+                  base::Bind(&PnaclHost::CopyFileToBuffer,
+                             entry->second.nexe_fd),
+                  base::Bind(&PnaclHost::StoreTranslatedNexe,
+                             weak_factory_.GetWeakPtr(),
+                             id))) {
     store_nexe = false;
   }
 
   if (!store_nexe) {
     // If store_nexe is true, the fd will be closed by CopyFileToBuffer.
     if (entry->second.got_nexe_fd) {
       BrowserThread::PostBlockingPoolTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(base::ClosePlatformFile),
                      entry->second.nexe_fd));
@@ skipping 161 matching lines @@
       end_time,
       base::Bind(&PnaclHost::OnEntriesDoomed, callback));
   if (rv != net::ERR_IO_PENDING)
     OnEntriesDoomed(callback, rv);
 }
 
 // static
 void PnaclHost::OnEntriesDoomed(const base::Closure& callback, int net_error) {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback);
 }