components/nacl/browser/pnacl_host.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_NACL_BROWSER_PNACL_HOST_H_
   6 #define COMPONENTS_NACL_BROWSER_PNACL_HOST_H_
   7
   8 #include <map>
   9
  10 #include "base/callback_forward.h"
  11 #include "base/files/file.h"
  12 #include "base/memory/singleton.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/threading/thread_checker.h"
  15 #include "components/nacl/browser/nacl_file_host.h"
  16 #include "components/nacl/common/pnacl_types.h"
  17 #include "ipc/ipc_platform_file.h"
  18
  19 namespace net {
  20 class DrainableIOBuffer;
  21 }
  22
  23 namespace pnacl {
  24
  25 class PnaclHostTest;
  26 class PnaclHostTestDisk;
  27 class PnaclTranslationCache;
  28
  29 // Shared state (translation cache) and common utilities (temp file creation)
  30 // for all PNaCl translations. Unless otherwise specified, all methods should be
  31 // called on the IO thread.
  32 class PnaclHost {
  33  public:
  34   typedef base::Callback<void(base::File)> TempFileCallback;
  35   typedef base::Callback<void(const base::File&, bool is_hit)> NexeFdCallback;
  36
  37   static PnaclHost* GetInstance();
  38
  39   PnaclHost();
  40   ~PnaclHost();
  41
  42   // Initialize cache backend. GetNexeFd will also initialize the backend if
  43   // necessary, but calling Init ahead of time will minimize the latency.
  44   void Init();
  45
  46   // Creates a temporary file that will be deleted when the last handle
  47   // is closed, or earlier. Returns a PlatformFile handle.
  48   void CreateTemporaryFile(TempFileCallback cb);
  49
  50   // Create a temporary file, which will be deleted by the time the last
  51   // handle is closed (or earlier on POSIX systems), to use for the nexe
  52   // with the cache information given in |cache_info|. The specific instance
  53   // is identified by the combination of |render_process_id| and |pp_instance|.
  54   // Returns by calling |cb| with a PlatformFile handle.
  55   // If the nexe is already present
  56   // in the cache, |is_hit| is set to true and the contents of the nexe
  57   // have been copied into the temporary file. Otherwise |is_hit| is set to
  58   // false and the temporary file will be writeable.
  59   // Currently the implementation is a stub, which always sets is_hit to false
  60   // and calls the implementation of CreateTemporaryFile.
  61   // If the cache request was a miss, the caller is expected to call
  62   // TranslationFinished after it finishes translation to allow the nexe to be
  63   // stored in the cache.
  64   // The returned temp fd may be closed at any time by PnaclHost, so it should
  65   // be duplicated (e.g. with IPC::GetFileHandleForProcess) before the callback
  66   // returns.
  67   // If |is_incognito| is true, the nexe will not be stored
  68   // in the cache, but the renderer is still expected to call
  69   // TranslationFinished.
  70   void GetNexeFd(int render_process_id,
  71                  int render_view_id,
  72                  int pp_instance,
  73                  bool is_incognito,
  74                  const nacl::PnaclCacheInfo& cache_info,
  75                  const NexeFdCallback& cb);
  76
  77   // Called after the translation of a pexe instance identified by
  78   // |render_process_id| and |pp_instance| finishes. If |success| is true,
  79   // store the nexe translated for the instance in the cache.
  80   void TranslationFinished(int render_process_id,
  81                            int pp_instance,
  82                            bool success);
  83
  84   // Called when the renderer identified by |render_process_id| is closing.
  85   // Clean up any outstanding translations for that renderer. If there are no
  86   // more pending translations, the backend is freed, allowing it to flush.
  87   void RendererClosing(int render_process_id);
  88
  89   // Doom all entries between |initial_time| and |end_time|. Like disk_cache_,
  90   // PnaclHost supports supports unbounded deletes in either direction by using
  91   // null Time values for either argument. |callback| will be called on the UI
  92   // thread when finished.
  93   void ClearTranslationCacheEntriesBetween(base::Time initial_time,
  94                                            base::Time end_time,
  95                                            const base::Closure& callback);
  96
  97   // Return the number of tracked translations or FD requests currently pending.
  98   size_t pending_translations() { return pending_translations_.size(); }
  99
 100  private:
 101   // PnaclHost is a singleton because there is only one translation cache, and
 102   // so that the BrowsingDataRemover can clear it even if no translation has
 103   // ever been started.
 104   friend struct base::DefaultSingletonTraits<PnaclHost>;
 105   friend class FileProxy;
 106   friend class pnacl::PnaclHostTest;
 107   friend class pnacl::PnaclHostTestDisk;
 108   enum CacheState {
 109     CacheUninitialized,
 110     CacheInitializing,
 111     CacheReady
 112   };
 113   class PendingTranslation {
 114    public:
 115     PendingTranslation();
 116     ~PendingTranslation();
 117     base::ProcessHandle process_handle;
 118     int render_view_id;
 119     base::File* nexe_fd;
 120     bool got_nexe_fd;
 121     bool got_cache_reply;
 122     bool got_cache_hit;
 123     bool is_incognito;
 124     scoped_refptr<net::DrainableIOBuffer> nexe_read_buffer;
 125     NexeFdCallback callback;
 126     std::string cache_key;
 127     nacl::PnaclCacheInfo cache_info;
 128   };
 129
 130   typedef std::pair<int, int> TranslationID;
 131   typedef std::map<TranslationID, PendingTranslation> PendingTranslationMap;
 132   static bool TranslationMayBeCached(
 133       const PendingTranslationMap::iterator& entry);
 134
 135   void InitForTest(base::FilePath temp_dir, bool in_memory);
 136   void OnCacheInitialized(int net_error);
 137
 138   static void DoCreateTemporaryFile(base::FilePath temp_dir_,
 139                                     TempFileCallback cb);
 140
 141   // GetNexeFd common steps
 142   void SendCacheQueryAndTempFileRequest(const std::string& key,
 143                                         const TranslationID& id);
 144   void OnCacheQueryReturn(const TranslationID& id,
 145                           int net_error,
 146                           scoped_refptr<net::DrainableIOBuffer> buffer);
 147   void OnTempFileReturn(const TranslationID& id, base::File file);
 148   void CheckCacheQueryReady(const PendingTranslationMap::iterator& entry);
 149
 150   // GetNexeFd miss path
 151   void ReturnMiss(const PendingTranslationMap::iterator& entry);
 152   static scoped_refptr<net::DrainableIOBuffer> CopyFileToBuffer(
 153       scoped_ptr<base::File> file);
 154   void StoreTranslatedNexe(TranslationID id,
 155                            scoped_refptr<net::DrainableIOBuffer>);
 156   void OnTranslatedNexeStored(const TranslationID& id, int net_error);
 157   void RequeryMatchingTranslations(const std::string& key);
 158
 159   // GetNexeFd hit path
 160   void OnBufferCopiedToTempFile(const TranslationID& id,
 161                                 scoped_ptr<base::File> file,
 162                                 int file_error);
 163
 164   void OnEntriesDoomed(const base::Closure& callback, int net_error);
 165
 166   void DeInitIfSafe();
 167
 168   // Operations which are pending with the cache backend, which we should
 169   // wait for before destroying it (see comment on DeInitIfSafe).
 170   int pending_backend_operations_;
 171   CacheState cache_state_;
 172   base::FilePath temp_dir_;
 173   scoped_ptr<pnacl::PnaclTranslationCache> disk_cache_;
 174   PendingTranslationMap pending_translations_;
 175   base::ThreadChecker thread_checker_;
 176   base::WeakPtrFactory<PnaclHost> weak_factory_;
 177   DISALLOW_COPY_AND_ASSIGN(PnaclHost);
 178 };
 179
 180 }  // namespace pnacl
 181
 182 #endif  // COMPONENTS_NACL_BROWSER_PNACL_HOST_H_