Use a raw pointer instead of Singleton for PnaclHost and leak it.

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 <stddef.h>
 
 #include <map>
 #include <memory>
 
-#include "base/callback_forward.h"
+#include "base/callback.h"
 #include "base/files/file.h"
 #include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "components/nacl/browser/nacl_file_host.h"
 #include "components/nacl/common/pnacl_types.h"
 #include "ipc/ipc_platform_file.h"
 
 namespace net {
 class DrainableIOBuffer;
 }
 
 namespace pnacl {
 
 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(const base::File&, bool is_hit)> NexeFdCallback;
 
+  // Gets the PnaclHost singleton instance (creating it if necessary).
+  // 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.
   static PnaclHost* GetInstance();
 
-  PnaclHost();
-  ~PnaclHost();
+  // The PnaclHost instance is intentionally leaked on shutdown. DeInitIfSafe()
+  // attempts to cleanup |disk_cache_| earlier, but if it fails to do so in
+  // time, it will be too late when AtExitManager kicks in anway so subscribing
+  // to it is useless.
+  ~PnaclHost() = delete;
 
   // Initialize cache backend. GetNexeFd will also initialize the backend if
   // necessary, but calling Init ahead of time will minimize the latency.
   void Init();
 
   // Creates a temporary file that will be deleted when the last handle
   // is closed, or earlier. Returns a PlatformFile handle.
   void CreateTemporaryFile(TempFileCallback cb);
 
   // Create a temporary file, which will be deleted by the time the last
@@ skipping 37 matching lines @@
 
   // Doom all entries between |initial_time| and |end_time|. Like disk_cache_,
   // PnaclHost supports supports unbounded deletes in either direction by using
   // null Time values for either argument. |callback| will be called on the UI
   // thread when finished.
   void ClearTranslationCacheEntriesBetween(base::Time initial_time,
                                            base::Time end_time,
                                            const base::Closure& callback);
 
   // Return the number of tracked translations or FD requests currently pending.
-  size_t pending_translations() { return pending_translations_.size(); }
+  size_t pending_translations() {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    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 base::DefaultSingletonTraits<PnaclHost>;
   friend class FileProxy;
-  friend class pnacl::PnaclHostTest;
-  friend class pnacl::PnaclHostTestDisk;
+  friend class PnaclHostTest;
+  friend class PnaclHostTestDisk;
   enum CacheState {
     CacheUninitialized,
     CacheInitializing,
     CacheReady
   };
   class PendingTranslation {
    public:
     PendingTranslation();
     PendingTranslation(const PendingTranslation& other);
     ~PendingTranslation();
     base::ProcessHandle process_handle;
     int render_view_id;
     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;
   };
 
   typedef std::pair<int, int> TranslationID;
   typedef std::map<TranslationID, PendingTranslation> PendingTranslationMap;
+
+  PnaclHost();
+
   static bool TranslationMayBeCached(
       const PendingTranslationMap::iterator& entry);
 
   void InitForTest(base::FilePath temp_dir, bool in_memory);
   void OnCacheInitialized(int net_error);
 
   static void DoCreateTemporaryFile(base::FilePath temp_dir_,
                                     TempFileCallback cb);
 
   // GetNexeFd common steps
@@ skipping 18 matching lines @@
   void OnBufferCopiedToTempFile(const TranslationID& id,
                                 std::unique_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_;
+  int pending_backend_operations_ = 0;
+  CacheState cache_state_ = CacheUninitialized;
   base::FilePath temp_dir_;
-  std::unique_ptr<pnacl::PnaclTranslationCache> disk_cache_;
+  std::unique_ptr<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_