Pepper: Move NexeLoadManager map inside that class.

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 71 matching lines @@
   base::ProcessId plugin_pid;
   int plugin_child_id;
   IPC::ChannelHandle channel_handle;
 };
 
 typedef std::map<PP_Instance, InstanceInfo> InstanceInfoMap;
 
 base::LazyInstance<InstanceInfoMap> g_instance_info =
     LAZY_INSTANCE_INITIALIZER;
 
-typedef base::ScopedPtrHashMap<PP_Instance, NexeLoadManager>
-    NexeLoadManagerMap;
-
-base::LazyInstance<NexeLoadManagerMap> g_load_manager_map =
-    LAZY_INSTANCE_INITIALIZER;
-
-nacl::NexeLoadManager* GetNexeLoadManager(PP_Instance instance) {
-  NexeLoadManagerMap& map = g_load_manager_map.Get();
-  NexeLoadManagerMap::iterator iter = map.find(instance);
-  if (iter != map.end())
-    return iter->second;
-  return NULL;
-}
-
 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());
   content::RendererPpapiHost *host =
@@ skipping 48 matching lines @@
  public:
   ManifestServiceProxy(PP_Instance pp_instance)
       : pp_instance_(pp_instance) {
   }
 
   virtual ~ManifestServiceProxy() { }
 
   virtual void StartupInitializationComplete() OVERRIDE {
     if (StartPpapiProxy(pp_instance_) == PP_TRUE) {
       JsonManifest* manifest = GetJsonManifest(pp_instance_);
-      NexeLoadManager* load_manager = GetNexeLoadManager(pp_instance_);
+      NexeLoadManager* load_manager = NexeLoadManager::Get(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 177 matching lines @@
           &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;
   }
 
   if (!error_message_string.empty()) {
     if (PP_ToBool(main_service_runtime)) {
-      NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+      NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
       if (load_manager) {
         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;
 
   *(static_cast<NaClHandle*>(imc_handle)) = ToNativeHandle(result_socket);
 
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (!load_manager) {
     PostPPCompletionCallback(callback, PP_ERROR_FAILED);
     return;
   }
 
   // Create the trusted plugin channel.
   if (IsValidChannelHandle(launch_result.trusted_ipc_channel_handle)) {
     scoped_ptr<TrustedPluginChannel> trusted_plugin_channel(
         new TrustedPluginChannel(
@@ skipping 25 matching lines @@
         manifest_service_channel.Pass());
   } else {
     // Currently, manifest service works only on linux/non-SFI mode.
     // On other platforms, 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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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;
   }
@@ skipping 180 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 = GetNexeLoadManager(instance);
+    NexeLoadManager* load_manager = NexeLoadManager::Get(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());
     }
   }
@@ skipping 58 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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   if (load_manager)
     load_manager->ReportLoadError(error, error_message);
 }
 
 void ReportLoadAbort(PP_Instance instance) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   if (load_manager)
     load_manager->ReportLoadAbort();
 }
 
 void NexeDidCrash(PP_Instance instance, const char* crash_log) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   if (load_manager)
     load_manager->NexeDidCrash(crash_log);
 }
 
 void InstanceCreated(PP_Instance instance) {
-  scoped_ptr<NexeLoadManager> new_load_manager(new NexeLoadManager(instance));
-  NexeLoadManagerMap& map = g_load_manager_map.Get();
-  DLOG_IF(ERROR, map.count(instance) != 0) << "Instance count should be 0";
-  map.add(instance, new_load_manager.Pass());
+  NexeLoadManager::Create(instance);
 }
 
 void InstanceDestroyed(PP_Instance instance) {
   DeleteJsonManifest(instance);
-
-  NexeLoadManagerMap& map = g_load_manager_map.Get();
-  DLOG_IF(ERROR, map.count(instance) == 0) << "Could not find instance ID";
-  // 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<NexeLoadManager> temp(map.take(instance));
-  map.erase(instance);
+  NexeLoadManager::Delete(instance);
 }
 
 PP_Bool NaClDebugEnabledForURL(const char* alleged_nmf_url) {
   if (!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 LogToConsole(PP_Instance instance, const char* message) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (load_manager)
     load_manager->LogToConsole(std::string(message));
 }
 
 PP_NaClReadyState GetNaClReadyState(PP_Instance instance) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->nacl_ready_state();
   return PP_NACL_READY_STATE_UNSENT;
 }
 
 int32_t GetExitStatus(PP_Instance instance) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->exit_status();
   return -1;
 }
 
 void SetExitStatus(PP_Instance instance, int32_t exit_status) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->set_exit_status(exit_status);
 }
 
 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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (load_manager)
     load_manager->InitializePlugin(argc, argn, argv);
 }
 
 int64_t GetNexeSize(PP_Instance instance) {
-  NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->nexe_size();
   return 0;
 }
 
 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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(instance);
   if (load_manager)
     load_manager->ProcessNaClManifest(program_url);
 }
 
 PP_Bool DevInterfacesEnabled(PP_Instance instance) {
-  nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
+  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(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());
     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 = GetNexeLoadManager(instance);
+  nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+      nacl::NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 211 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 = GetNexeLoadManager(request.instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 = GetNexeLoadManager(instance);
+  NexeLoadManager* load_manager = NexeLoadManager::Get(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 201 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl