Remove some PlatformFile uses from NaCl.

components/nacl/browser/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 "components/nacl/browser/pnacl_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/pnacl_translation_cache.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace {

[Mark Seaborn, 2014/02/14 19:00:08]

Nit: add empty line after this so that the start and end of the namespace block
are consistent

[rvargas (doing something else), 2014/02/14 19:37:15]

oops. done.

 static const base::FilePath::CharType kTranslationCacheDirectoryName[] =
     FILE_PATH_LITERAL("PnaclTranslationCache");
 // Delay to wait for initialization of the cache backend
 static const int kTranslationCacheInitializationDelayMs = 20;
+
+void CloseBaseFile(base::File file) {
+  // Not really needed because the file will go out of scope here.
+  file.Close();
+}
+
 }
 
 namespace pnacl {
 
 PnaclHost::PnaclHost()
     : pending_backend_operations_(0),
       cache_state_(CacheUninitialized),
       weak_factory_(this) {}
 
 PnaclHost::~PnaclHost() {
@@ skipping 97 matching lines @@
 
 ///////////////////////////////////////// Temp files
 
 // Create a temporary file on the blocking pool
 // static
 void PnaclHost::DoCreateTemporaryFile(base::FilePath temp_dir,
                                       TempFileCallback cb) {
   DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   base::FilePath file_path;
-  base::PlatformFile file_handle(base::kInvalidPlatformFileValue);
+  base::File file;
   bool rv = temp_dir.empty()
                 ? base::CreateTemporaryFile(&file_path)
                 : base::CreateTemporaryFileInDir(temp_dir, &file_path);
   if (!rv) {
     PLOG(ERROR) << "Temp file creation failed.";
   } else {
-    base::PlatformFileError error;
-    file_handle = base::CreatePlatformFile(
+    file.Initialize(
         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);
+        base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_READ |
+            base::File::FLAG_WRITE | base::File::FLAG_TEMPORARY |
+            base::File::FLAG_DELETE_ON_CLOSE);
 
-    if (error != base::PLATFORM_FILE_OK) {
-      PLOG(ERROR) << "Temp file open failed: " << error;
-      file_handle = base::kInvalidPlatformFileValue;
-    }
+    if (!file.IsValid())
+      PLOG(ERROR) << "Temp file open failed: " << file.error_details();
   }
   BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(cb, file_handle));
+      BrowserThread::IO, FROM_HERE, base::Bind(cb, Passed(file.Pass())));
 }
 
 void PnaclHost::CreateTemporaryFile(TempFileCallback cb) {
   if (!BrowserThread::PostBlockingPoolSequencedTask(
            "PnaclHostCreateTempFile",
            FROM_HERE,
            base::Bind(&PnaclHost::DoCreateTemporaryFile, temp_dir_, cb))) {
     DCHECK(thread_checker_.CalledOnValidThread());
-    cb.Run(base::kInvalidPlatformFileValue);
+    cb.Run(base::File());
   }
 }
 
 ///////////////////////////////////////// GetNexeFd implementation
 ////////////////////// Common steps
 
 void PnaclHost::GetNexeFd(int render_process_id,
                           int render_view_id,
                           int pp_instance,
                           bool is_incognito,
@@ skipping 80 matching lines @@
   }
   PendingTranslation* pt = &entry->second;
   pt->got_cache_reply = true;
   pt->got_cache_hit = (net_error == net::OK);
   if (pt->got_cache_hit)
     pt->nexe_read_buffer = buffer;
   CheckCacheQueryReady(entry);
 }
 
 // Callback from temp file creation. |id| is bound from
-// SendCacheQueryAndTempFileRequest, and fd is the created file descriptor.
+// SendCacheQueryAndTempFileRequest, and |file| is the created file.
 // If there was an error, fd is kInvalidPlatformFileValue.
 // (Bound callbacks must re-lookup the TranslationID because the translation
 // could be cancelled before they get called).
 void PnaclHost::OnTempFileReturn(const TranslationID& id,
-                                 base::PlatformFile fd) {
+                                 base::File file) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PendingTranslationMap::iterator entry(pending_translations_.find(id));
   if (entry == pending_translations_.end()) {
     // The renderer may have signaled an error or closed while the temp
     // file was being created.
     LOG(ERROR) << "OnTempFileReturn: id not found";
     BrowserThread::PostBlockingPoolTask(
-        FROM_HERE, base::Bind(base::IgnoreResult(base::ClosePlatformFile), fd));
+        FROM_HERE, base::Bind(CloseBaseFile, Passed(file.Pass())));
     return;
   }
-  if (fd == base::kInvalidPlatformFileValue) {
+  if (!file.IsValid()) {
     // This translation will fail, but we need to retry any translation
     // waiting for its result.
     LOG(ERROR) << "OnTempFileReturn: temp file creation failed";
     std::string key(entry->second.cache_key);
-    entry->second.callback.Run(fd, false);
+    entry->second.callback.Run(base::kInvalidPlatformFileValue, false);
     bool may_be_cached = TranslationMayBeCached(entry);
     pending_translations_.erase(entry);
     // No translations will be waiting for entries that will not be stored.
     if (may_be_cached)
       RequeryMatchingTranslations(key);
     return;
   }
   PendingTranslation* pt = &entry->second;
   pt->got_nexe_fd = true;
-  pt->nexe_fd = fd;
+  pt->nexe_fd = file.TakePlatformFile();
   CheckCacheQueryReady(entry);
 }
 
 // Check whether both the cache query and the temp file have returned, and check
 // whether we actually got a hit or not.
 void PnaclHost::CheckCacheQueryReady(
     const PendingTranslationMap::iterator& entry) {
   PendingTranslation* pt = &entry->second;
   if (!(pt->got_cache_reply && pt->got_nexe_fd))
     return;
@@ skipping 316 matching lines @@
   DCHECK(pending_backend_operations_ >= 0);
   if (pending_translations_.empty() &&
       pending_backend_operations_ <= 0 &&
       cache_state_ == CacheReady) {
     cache_state_ = CacheUninitialized;
     disk_cache_.reset();
   }
 }
 
 }  // namespace pnacl