NaCl: Merge three global PP_Instance mappings into one

components/nacl/renderer/ppb_nacl_private_impl.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/renderer/ppb_nacl_private_impl.h"
 
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_nonsfi_util.h"
@@ skipping 57 matching lines @@
   if (!render_thread)
     return false;
   if (!g_pnacl_resource_host.Get().get()) {
     g_pnacl_resource_host.Get() = new PnaclTranslationResourceHost(
         render_thread->GetIOMessageLoopProxy());
     render_thread->AddFilter(g_pnacl_resource_host.Get().get());
   }
   return true;
 }
 
+// This contains state that is produced by LaunchSelLdr() and consumed
+// by StartPpapiProxy().
 struct InstanceInfo {
   InstanceInfo() : plugin_pid(base::kNullProcessId), plugin_child_id(0) {}
   GURL url;
   ppapi::PpapiPermissions permissions;
   base::ProcessId plugin_pid;
   int plugin_child_id;
   IPC::ChannelHandle channel_handle;
 };
 
-typedef std::map<PP_Instance, InstanceInfo> InstanceInfoMap;
+class NaClPluginInstance {
+ public:
+  NaClPluginInstance(PP_Instance instance): nexe_load_manager(instance) {}
 
-base::LazyInstance<InstanceInfoMap> g_instance_info =
-    LAZY_INSTANCE_INITIALIZER;
+  NexeLoadManager nexe_load_manager;
+  scoped_ptr<JsonManifest> json_manifest;
+  scoped_ptr<InstanceInfo> instance_info;
+};
+
+typedef base::ScopedPtrHashMap<PP_Instance, NaClPluginInstance> InstanceMap;
+base::LazyInstance<InstanceMap> g_instance_map = LAZY_INSTANCE_INITIALIZER;
+
+NaClPluginInstance* GetNaClPluginInstance(PP_Instance instance) {
+  InstanceMap& map = g_instance_map.Get();
+  InstanceMap::iterator iter = map.find(instance);
+  if (iter == map.end())
+    return NULL;
+  return iter->second;
+}
+
+NexeLoadManager* GetNexeLoadManager(PP_Instance instance) {
+  NaClPluginInstance* nacl_plugin_instance = GetNaClPluginInstance(instance);
+  if (!nacl_plugin_instance)
+    return NULL;
+  return &nacl_plugin_instance->nexe_load_manager;
+}
+
+JsonManifest* GetJsonManifest(PP_Instance instance) {
+  NaClPluginInstance* nacl_plugin_instance = GetNaClPluginInstance(instance);
+  if (!nacl_plugin_instance)
+    return NULL;
+  return nacl_plugin_instance->json_manifest.get();
+}
 
 static const PP_NaClFileInfo kInvalidNaClFileInfo = {
     PP_kInvalidFileHandle,
     0,  // token_lo
     0,  // token_hi
 };
 
 int GetRoutingID(PP_Instance instance) {
   // Check that we are on the main renderer thread.
   DCHECK(content::RenderThread::Get());
@@ skipping 48 matching lines @@
 class ManifestServiceProxy : public ManifestServiceChannel::Delegate {
  public:
   ManifestServiceProxy(PP_Instance pp_instance, bool is_helper_process)
       : pp_instance_(pp_instance), is_helper_process_(is_helper_process) {}
 
   ~ManifestServiceProxy() override {}
 
   void StartupInitializationComplete() override {
     if (StartPpapiProxy(pp_instance_) == PP_TRUE) {
       JsonManifest* manifest = GetJsonManifest(pp_instance_);
-      NexeLoadManager* load_manager = NexeLoadManager::Get(pp_instance_);
+      NexeLoadManager* load_manager = GetNexeLoadManager(pp_instance_);
       if (load_manager && manifest) {
         std::string full_url;
         PP_PNaClOptions pnacl_options;
         bool uses_nonsfi_mode;
         JsonManifest::ErrorInfo error_info;
         if (manifest->GetProgramURL(&full_url,
                                     &pnacl_options,
                                     &uses_nonsfi_mode,
                                     &error_info)) {
           int64_t nexe_size = load_manager->nexe_size();
@@ skipping 186 matching lines @@
               process_type),
           &launch_result,
           &error_message_string))) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager) {
     PostPPCompletionCallback(callback, PP_ERROR_FAILED);
     base::SharedMemory::CloseHandle(launch_result.crash_info_shmem_handle);
     return;
   }
   load_manager->set_nonsfi(PP_ToBool(uses_nonsfi_mode));
 
   if (!error_message_string.empty()) {
     if (PP_ToBool(main_service_runtime)) {
       load_manager->ReportLoadError(PP_NACL_ERROR_SEL_LDR_LAUNCH,
                                     "ServiceRuntime: failed to start",
                                     error_message_string);
     }
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
   result_socket = launch_result.imc_channel_handle;
   instance_info.channel_handle = launch_result.ppapi_ipc_channel_handle;
   instance_info.plugin_pid = launch_result.plugin_pid;
   instance_info.plugin_child_id = launch_result.plugin_child_id;
 
   // Don't save instance_info if channel handle is invalid.
-  if (IsValidChannelHandle(instance_info.channel_handle))
-    g_instance_info.Get()[instance] = instance_info;
+  if (IsValidChannelHandle(instance_info.channel_handle)) {
+    NaClPluginInstance* nacl_plugin_instance = GetNaClPluginInstance(instance);
+    nacl_plugin_instance->instance_info.reset(new InstanceInfo(instance_info));
+  }
 
   *(static_cast<NaClHandle*>(imc_handle)) = ToNativeHandle(result_socket);
 
   // Store the crash information shared memory handle.
   load_manager->set_crash_info_shmem_handle(
       launch_result.crash_info_shmem_handle);
 
   // Create the trusted plugin channel.
   if (IsValidChannelHandle(launch_result.trusted_ipc_channel_handle)) {
     bool report_exit_status = PP_ToBool(main_service_runtime);
@@ skipping 27 matching lines @@
         manifest_service_channel.Pass());
   } else {
     // The manifest service is not used for some cases like PNaCl pexes.
     // In that case, the socket will not be created, and thus this
     // condition needs to be handled as success.
     PostPPCompletionCallback(callback, PP_OK);
   }
 }
 
 PP_Bool StartPpapiProxy(PP_Instance instance) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_FALSE;
 
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
     DLOG(ERROR) << "GetInstance() failed";
     return PP_FALSE;
   }
 
-  InstanceInfoMap& map = g_instance_info.Get();
-  InstanceInfoMap::iterator it = map.find(instance);
-  if (it == map.end()) {
+  NaClPluginInstance* nacl_plugin_instance = GetNaClPluginInstance(instance);
+  if (!nacl_plugin_instance->instance_info) {
     DLOG(ERROR) << "Could not find instance ID";
     return PP_FALSE;
   }
-  InstanceInfo instance_info = it->second;
-  map.erase(it);
+  scoped_ptr<InstanceInfo> instance_info =
+      nacl_plugin_instance->instance_info.Pass();
 
   PP_ExternalPluginResult result = plugin_instance->SwitchToOutOfProcessProxy(
-      base::FilePath().AppendASCII(instance_info.url.spec()),
-      instance_info.permissions,
-      instance_info.channel_handle,
-      instance_info.plugin_pid,
-      instance_info.plugin_child_id);
+      base::FilePath().AppendASCII(instance_info->url.spec()),
+      instance_info->permissions,
+      instance_info->channel_handle,
+      instance_info->plugin_pid,
+      instance_info->plugin_child_id);
 
   if (result == PP_EXTERNAL_PLUGIN_OK) {
     // Log the amound of time that has passed between the trusted plugin being
     // initialized and the untrusted plugin being initialized.  This is
     // (roughly) the cost of using NaCl, in terms of startup time.
     load_manager->ReportStartupOverhead();
     return PP_TRUE;
   } else if (result == PP_EXTERNAL_PLUGIN_ERROR_MODULE) {
     load_manager->ReportLoadError(PP_NACL_ERROR_START_PROXY_MODULE,
                                   "could not initialize module.");
@@ skipping 145 matching lines @@
     if (opt_level < 0 || opt_level > 3)
       opt_level = kUnknownOptLevel;
     HistogramEnumerate("NaCl.Options.PNaCl.OptLevel",
                        opt_level,
                        kUnknownOptLevel + 1);
     HistogramKBPerSec("NaCl.Perf.PNaClLoadTime.CompileKBPerSec",
                       pexe_size / 1024,
                       compile_time_us);
     HistogramSizeKB("NaCl.Perf.Size.Pexe", pexe_size / 1024);
 
-    NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+    NexeLoadManager* load_manager = GetNexeLoadManager(instance);
     if (load_manager) {
       base::TimeDelta total_time = base::Time::Now() -
                                    load_manager->pnacl_start_time();
       HistogramTimeTranslation("NaCl.Perf.PNaClLoadTime.TotalUncachedTime",
                                total_time.InMilliseconds());
       HistogramKBPerSec("NaCl.Perf.PNaClLoadTime.TotalUncachedKBPerSec",
                         pexe_size / 1024,
                         total_time.InMicroseconds());
     }
   }
 
   // If the resource host isn't initialized, don't try to do that here.
   // Just return because something is already very wrong.
   if (g_pnacl_resource_host.Get().get() == NULL)
     return;
   g_pnacl_resource_host.Get()->ReportTranslationFinished(instance, success);
 }
 
 PP_FileHandle OpenNaClExecutable(PP_Instance instance,
                                  const char* file_url,
                                  uint64_t* nonce_lo,
                                  uint64_t* nonce_hi) {
   // Fast path only works for installed file URLs.
   GURL gurl(file_url);
   if (!gurl.SchemeIs("chrome-extension"))
     return PP_kInvalidFileHandle;
 
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_kInvalidFileHandle;
 
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance)
     return PP_kInvalidFileHandle;
   // IMPORTANT: Make sure the document can request the given URL. If we don't
   // check, a malicious app could probe the extension system. This enforces a
@@ skipping 36 matching lines @@
                       resource_url,
                       PP_ToBool(length_is_computable),
                       loaded_bytes,
                       total_bytes);
   DispatchProgressEvent(instance, event);
 }
 
 void ReportLoadSuccess(PP_Instance instance,
                        uint64_t loaded_bytes,
                        uint64_t total_bytes) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager) {
     load_manager->ReportLoadSuccess(load_manager->program_url(),
                                     loaded_bytes,
                                     total_bytes);
   }
 }
 
 void ReportLoadError(PP_Instance instance,
                      PP_NaClError error,
                      const char* error_message) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->ReportLoadError(error, error_message);
 }
 
 void InstanceCreated(PP_Instance instance) {
-  NexeLoadManager::Create(instance);
+  InstanceMap& map = g_instance_map.Get();
+  CHECK(map.find(instance) == map.end()); // Sanity check.
+  scoped_ptr<NaClPluginInstance> new_instance(new NaClPluginInstance(instance));
+  map.add(instance, new_instance.Pass());
 }
 
 void InstanceDestroyed(PP_Instance instance) {
-  DeleteJsonManifest(instance);
-  NexeLoadManager::Delete(instance);
+  InstanceMap& map = g_instance_map.Get();
+  InstanceMap::iterator iter = map.find(instance);
+  CHECK(iter != map.end());
+  // The erase may call NexeLoadManager's destructor prior to removing it from
+  // the map. In that case, it is possible for the trusted Plugin to re-enter
+  // the NexeLoadManager (e.g., by calling ReportLoadError). Passing out the
+  // NexeLoadManager to a local scoped_ptr just ensures that its entry is gone
+  // from the map prior to the destructor being invoked.
+  scoped_ptr<NaClPluginInstance> temp(map.take(instance));
+  map.erase(iter);
 }
 
 PP_Bool NaClDebugEnabledForURL(const char* alleged_nmf_url) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNaClDebug))
     return PP_FALSE;
   IPC::Sender* sender = content::RenderThread::Get();
   DCHECK(sender);
   bool should_debug = false;
   return PP_FromBool(
       sender->Send(new NaClHostMsg_NaClDebugEnabledForURL(GURL(alleged_nmf_url),
                                                           &should_debug)) &&
       should_debug);
 }
 
 void Vlog(const char* message) {
   VLOG(1) << message;
 }
 
 void InitializePlugin(PP_Instance instance,
                       uint32_t argc,
                       const char* argn[],
                       const char* argv[]) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (load_manager)
     load_manager->InitializePlugin(argc, argn, argv);
 }
 
 void DownloadManifestToBuffer(PP_Instance instance,
                               struct PP_CompletionCallback callback);
 
 bool CreateJsonManifest(PP_Instance instance,
                         const std::string& manifest_url,
                         const std::string& manifest_data);
 
 void RequestNaClManifest(PP_Instance instance,
                          PP_CompletionCallback callback) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   std::string url = load_manager->GetManifestURLArgument();
@@ skipping 26 matching lines @@
     }
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data, error));
   } else {
     DownloadManifestToBuffer(instance, callback);
   }
 }
 
 PP_Var GetManifestBaseURL(PP_Instance instance) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_MakeUndefined();
   const GURL& gurl = load_manager->manifest_base_url();
   if (!gurl.is_valid())
     return PP_MakeUndefined();
   return ppapi::StringVar::StringToPPVar(gurl.spec());
 }
 
 void ProcessNaClManifest(PP_Instance instance, const char* program_url) {
-  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->ProcessNaClManifest(program_url);
 }
 
 PP_Bool DevInterfacesEnabled(PP_Instance instance) {
-  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     return PP_FromBool(load_manager->DevInterfacesEnabled());
   return PP_FALSE;
 }
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
                                         base::Time start_time,
                                         PP_NaClError pp_nacl_error,
                                         const std::string& data);
 
 void DownloadManifestToBuffer(PP_Instance instance,
                               struct PP_CompletionCallback callback) {
-  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!load_manager || !plugin_instance) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
   }
   const blink::WebDocument& document =
@@ skipping 15 matching lines @@
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
                                         base::Time start_time,
                                         PP_NaClError pp_nacl_error,
                                         const std::string& data) {
   base::TimeDelta download_time = base::Time::Now() - start_time;
   HistogramTimeSmall("NaCl.Perf.StartupTime.ManifestDownload",
                      download_time.InMilliseconds());
 
-  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (!load_manager) {
     callback.func(callback.user_data, PP_ERROR_ABORTED);
     return;
   }
 
   int32_t pp_error;
   switch (pp_nacl_error) {
     case PP_NACL_ERROR_LOAD_SUCCESS:
       pp_error = PP_OK;
       break;
@@ skipping 26 matching lines @@
   }
   callback.func(callback.user_data, pp_error);
 }
 
 bool CreateJsonManifest(PP_Instance instance,
                         const std::string& manifest_url,
                         const std::string& manifest_data) {
   HistogramSizeKB("NaCl.Perf.Size.Manifest",
                   static_cast<int32_t>(manifest_data.length() / 1024));
 
-  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (!load_manager)
     return false;
 
   const char* isa_type;
   if (load_manager->IsPNaCl())
     isa_type = kPortableArch;
   else
     isa_type = GetSandboxArch();
 
   scoped_ptr<nacl::JsonManifest> j(
       new nacl::JsonManifest(
           manifest_url.c_str(),
           isa_type,
           IsNonSFIModeEnabled(),
           PP_ToBool(NaClDebugEnabledForURL(manifest_url.c_str()))));
   JsonManifest::ErrorInfo error_info;
   if (j->Init(manifest_data.c_str(), &error_info)) {
-    AddJsonManifest(instance, j.Pass());
+    GetNaClPluginInstance(instance)->json_manifest.reset(j.release());
     return true;
   }
   load_manager->ReportLoadError(error_info.error, error_info.string);
   return false;
 }
 
 PP_Bool ManifestGetProgramURL(PP_Instance instance,
                               PP_Var* pp_full_url,
                               PP_PNaClOptions* pnacl_options,
                               PP_Bool* pp_uses_nonsfi_mode) {
-  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
 
   JsonManifest* manifest = GetJsonManifest(instance);
   if (manifest == NULL)
     return PP_FALSE;
 
   bool uses_nonsfi_mode;
   std::string full_url;
   JsonManifest::ErrorInfo error_info;
   if (manifest->GetProgramURL(&full_url, pnacl_options, &uses_nonsfi_mode,
                               &error_info)) {
@@ skipping 12 matching lines @@
                         const std::string& key,
                         std::string* full_url,
                         PP_PNaClOptions* pnacl_options) {
   // For "helper" processes (llc and ld, for PNaCl translation), we resolve
   // keys manually as there is no existing .nmf file to parse.
   if (is_helper_process) {
     pnacl_options->translate = PP_FALSE;
     // We can only resolve keys in the files/ namespace.
     const std::string kFilesPrefix = "files/";
     if (key.find(kFilesPrefix) == std::string::npos) {
-      nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+      nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
       if (load_manager)
         load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_RESOLVE_URL,
                                       "key did not start with files/");
       return false;
     }
     std::string key_basename = key.substr(kFilesPrefix.length());
     *full_url = std::string(kPNaClTranslatorBaseUrl) + GetSandboxArch() + "/" +
                 key_basename;
     return true;
   }
 
   JsonManifest* manifest = GetJsonManifest(instance);
   if (manifest == NULL)
     return false;
 
   return manifest->ResolveKey(key, full_url, pnacl_options);
 }
 
 PP_Bool GetPNaClResourceInfo(PP_Instance instance,
                              PP_Var* llc_tool_name,
                              PP_Var* ld_tool_name) {
   static const char kFilename[] = "chrome://pnacl-translator/pnacl.json";
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_FALSE;
 
   uint64_t nonce_lo = 0;
   uint64_t nonce_hi = 0;
   base::File file(GetReadonlyPnaclFd(kFilename, false /* is_executable */,
                                      &nonce_lo, &nonce_hi));
   if (!file.IsValid()) {
     load_manager->ReportLoadError(
@@ skipping 192 matching lines @@
       bytes_read = info.size;
   }
 
   if (bytes_read == -1) {
     target_file.Close();
     pp_error = PP_ERROR_FAILED;
   }
 
   base::TimeDelta download_time = base::Time::Now() - request.start_time;
 
-  NexeLoadManager* load_manager = NexeLoadManager::Get(request.instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(request.instance);
   if (load_manager) {
     load_manager->NexeFileDidOpen(pp_error,
                                   target_file,
                                   http_status,
                                   bytes_read,
                                   request.url,
                                   download_time);
   }
 
   if (pp_error == PP_OK && target_file.IsValid())
@@ skipping 21 matching lines @@
 
   callback.Run(pp_error, file_info);
 }
 
 void DownloadFile(PP_Instance instance,
                   const std::string& url,
                   const DownloadFileCallback& callback) {
   DCHECK(ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->
              BelongsToCurrentThread());
 
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    static_cast<int32_t>(PP_ERROR_FAILED),
                    kInvalidNaClFileInfo));
     return;
   }
 
@@ skipping 79 matching lines @@
       base::Bind(&DownloadFileCompletion, callback),
       base::Bind(&ProgressEventRateLimiter::ReportProgress,
                  base::Owned(tracker), std::string(url)));
   file_downloader->Load(url_request);
 }
 
 void ReportSelLdrStatus(PP_Instance instance,
                         int32_t load_status,
                         int32_t max_status) {
   HistogramEnumerate("NaCl.LoadStatus.SelLdr", load_status, max_status);
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return;
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = load_manager->is_installed() ?
       "NaCl.LoadStatus.SelLdr.InstalledApp" :
       "NaCl.LoadStatus.SelLdr.NotInstalledApp";
   HistogramEnumerate(name, load_status, max_status);
 }
@@ skipping 34 matching lines @@
     PostPPCompletionCallback(callback, PP_ERROR_FAILED);
   }
 
   // TODO(teravest): Make a type like PP_NaClFileInfo to use for DownloadFile
   // that would close the file handle on destruction.
   DownloadFile(instance, url,
                base::Bind(&DidOpenManifestEntry, out_file_info, callback));
 }
 
 void SetPNaClStartTime(PP_Instance instance) {
-  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
+  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->set_pnacl_start_time(base::Time::Now());
 }
 
 // PexeDownloader is responsible for deleting itself when the download
 // finishes.
 class PexeDownloader : public blink::WebURLLoaderClient {
  public:
   PexeDownloader(PP_Instance instance,
                  scoped_ptr<blink::WebURLLoader> url_loader,
@@ skipping 191 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl