Pepper: Move NexeLoadManager map inside that class.

components/nacl/renderer/nexe_load_manager.cc

 // Copyright 2014 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/nexe_load_manager.h"
 
 #include "base/command_line.h"
+#include "base/containers/scoped_ptr_hash_map.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_types.h"
 #include "components/nacl/renderer/histogram.h"
 #include "components/nacl/renderer/manifest_service_channel.h"
 #include "components/nacl/renderer/platform_info.h"
 #include "components/nacl/renderer/pnacl_translation_resource_host.h"
@@ skipping 14 matching lines @@
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "v8/include/v8.h"
 
+namespace nacl {
+
 namespace {
 
 const char* const kTypeAttribute = "type";
 // The "src" attribute of the <embed> tag.  The value is expected to be either
 // a URL or URI pointing to the manifest file (which is expected to contain
 // JSON matching ISAs with .nexe URLs).
 const char* const kSrcManifestAttribute = "src";
 // The "nacl" attribute of the <embed> tag.  We use the value of this attribute
 // to find the manifest file when NaCl is registered as a plug-in for another
 // MIME type because the "src" attribute is used to supply us with the resource
@@ skipping 17 matching lines @@
 }
 
 std::string LookupAttribute(const std::map<std::string, std::string>& args,
                             const std::string& key) {
   std::map<std::string, std::string>::const_iterator it = args.find(key);
   if (it != args.end())
     return it->second;
   return std::string();
 }
 
+typedef base::ScopedPtrHashMap<PP_Instance, NexeLoadManager> NexeLoadManagerMap;
+base::LazyInstance<NexeLoadManagerMap> g_load_manager_map =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
-namespace nacl {
-
 NexeLoadManager::NexeLoadManager(
     PP_Instance pp_instance)
     : pp_instance_(pp_instance),
       nacl_ready_state_(PP_NACL_READY_STATE_UNSENT),
       nexe_error_reported_(false),
       is_installed_(false),
       exit_status_(-1),
       nexe_size_(0),
       plugin_instance_(content::PepperPluginInstance::Get(pp_instance)),
       crash_info_shmem_handle_(base::SharedMemory::NULLHandle()),
       weak_factory_(this) {
   SetLastError("");
   HistogramEnumerateOsArch(GetSandboxArch());
   if (plugin_instance_) {
     plugin_base_url_ =
         plugin_instance_->GetContainer()->element().document().url();
   }
 }
 
 NexeLoadManager::~NexeLoadManager() {
   if (!nexe_error_reported_) {
     base::TimeDelta uptime = base::Time::Now() - ready_time_;
     HistogramTimeLarge("NaCl.ModuleUptime.Normal", uptime.InMilliseconds());
   }
   if (base::SharedMemory::IsHandleValid(crash_info_shmem_handle_))
     base::SharedMemory::CloseHandle(crash_info_shmem_handle_);
 }
 
+void NexeLoadManager::Create(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* NexeLoadManager::Get(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;
+}
+
+void NexeLoadManager::Delete(PP_Instance instance) {
+  NexeLoadManagerMap& map = g_load_manager_map.Get();
+  // 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);
+}
+
 void NexeLoadManager::NexeFileDidOpen(int32_t pp_error,
                                       const base::File& file,
                                       int32_t http_status,
                                       int64_t nexe_bytes_read,
                                       const std::string& url,
                                       base::TimeDelta time_since_open) {
   // Check that we are on the main renderer thread.
   DCHECK(content::RenderThread::Get());
   VLOG(1) << "Plugin::NexeFileDidOpen (pp_error=" << pp_error << ")";
   HistogramHTTPStatusCode(
@@ skipping 315 matching lines @@
   // to provide error handling.
 }
 
 void NexeLoadManager::CopyCrashLogToJsConsole(const std::string& crash_log) {
   base::StringTokenizer t(crash_log, "\n");
   while (t.GetNext())
     LogToConsole(t.token());
 }
 
 }  // namespace nacl