Remove PlatformFile from components/nacl

components/nacl/browser/pnacl_host.h

 // 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.
 
 #ifndef COMPONENTS_NACL_BROWSER_PNACL_HOST_H_
 #define COMPONENTS_NACL_BROWSER_PNACL_HOST_H_
 
 #include <map>
 
 #include "base/callback_forward.h"
@@ skipping 14 matching lines @@
 class PnaclHostTest;
 class PnaclHostTestDisk;
 class PnaclTranslationCache;
 
 // Shared state (translation cache) and common utilities (temp file creation)
 // for all PNaCl translations. Unless otherwise specified, all methods should be
 // called on the IO thread.
 class PnaclHost {
  public:
   typedef base::Callback<void(base::File)> TempFileCallback;
-  typedef base::Callback<void(base::PlatformFile, bool is_hit)> NexeFdCallback;
+  typedef base::Callback<void(const base::File&, bool is_hit)> NexeFdCallback;
 
   static PnaclHost* GetInstance();
 
   PnaclHost();
   ~PnaclHost();
 
   // Initialize cache backend. GetNexeFd will also initialize the backend if
   // necessary, but calling Init ahead of time will minimize the latency.
   void Init();
 
@@ skipping 49 matching lines @@
                                            const base::Closure& callback);
 
   // Return the number of tracked translations or FD requests currently pending.
   size_t pending_translations() { return pending_translations_.size(); }
 
  private:
   // PnaclHost is a singleton because there is only one translation cache, and
   // so that the BrowsingDataRemover can clear it even if no translation has
   // ever been started.
   friend struct DefaultSingletonTraits<PnaclHost>;
+  friend class FileProxy;
   friend class pnacl::PnaclHostTest;
   friend class pnacl::PnaclHostTestDisk;
   enum CacheState {
     CacheUninitialized,
     CacheInitializing,
     CacheReady
   };
   class PendingTranslation {
    public:
     PendingTranslation();
     ~PendingTranslation();
     base::ProcessHandle process_handle;
     int render_view_id;
-    base::PlatformFile nexe_fd;
+    base::File* nexe_fd;
     bool got_nexe_fd;
     bool got_cache_reply;
     bool got_cache_hit;
     bool is_incognito;
     scoped_refptr<net::DrainableIOBuffer> nexe_read_buffer;
     NexeFdCallback callback;
     std::string cache_key;
     nacl::PnaclCacheInfo cache_info;
   };
 
@@ skipping 13 matching lines @@
                                         const TranslationID& id);
   void OnCacheQueryReturn(const TranslationID& id,
                           int net_error,
                           scoped_refptr<net::DrainableIOBuffer> buffer);
   void OnTempFileReturn(const TranslationID& id, base::File file);
   void CheckCacheQueryReady(const PendingTranslationMap::iterator& entry);
 
   // GetNexeFd miss path
   void ReturnMiss(const PendingTranslationMap::iterator& entry);
   static scoped_refptr<net::DrainableIOBuffer> CopyFileToBuffer(
-      base::PlatformFile fd);
+      scoped_ptr<base::File> file);
   void StoreTranslatedNexe(TranslationID id,
                            scoped_refptr<net::DrainableIOBuffer>);
   void OnTranslatedNexeStored(const TranslationID& id, int net_error);
   void RequeryMatchingTranslations(const std::string& key);
 
   // GetNexeFd hit path
-  static int CopyBufferToFile(base::PlatformFile fd,
-                              scoped_refptr<net::DrainableIOBuffer> buffer);
-  void OnBufferCopiedToTempFile(const TranslationID& id, int file_error);
+  void OnBufferCopiedToTempFile(const TranslationID& id,
+                                scoped_ptr<base::File> file,
+                                int file_error);
 
   void OnEntriesDoomed(const base::Closure& callback, int net_error);
 
   void DeInitIfSafe();
 
   // Operations which are pending with the cache backend, which we should
   // wait for before destroying it (see comment on DeInitIfSafe).
   int pending_backend_operations_;
   CacheState cache_state_;
   base::FilePath temp_dir_;
   scoped_ptr<pnacl::PnaclTranslationCache> disk_cache_;
   PendingTranslationMap pending_translations_;
   base::ThreadChecker thread_checker_;
   base::WeakPtrFactory<PnaclHost> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(PnaclHost);
 };
 
 }  // namespace pnacl
 
 #endif  // COMPONENTS_NACL_BROWSER_PNACL_HOST_H_