Pepper: Move JsonManifestMap to json_manifest.h

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>
 
@@ skipping 87 matching lines @@
 
 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;
 
-typedef base::ScopedPtrHashMap<PP_Instance, nacl::JsonManifest> JsonManifestMap;
-
-base::LazyInstance<JsonManifestMap> g_manifest_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;
 }
 
 int GetRoutingID(PP_Instance instance) {
   // Check that we are on the main renderer thread.
@@ skipping 634 matching lines @@
 }
 
 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());
 }
 
 void InstanceDestroyed(PP_Instance instance) {
-  g_manifest_map.Get().erase(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);
@@ skipping 263 matching lines @@
     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)) {
-    g_manifest_map.Get().add(instance, j.Pass());
+    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);
 
-  JsonManifestMap::iterator it = g_manifest_map.Get().find(instance);
-  if (it == g_manifest_map.Get().end())
+  JsonManifest* manifest = GetJsonManifest(instance);
+  if (manifest == NULL)
     return PP_FALSE;
 
   bool uses_nonsfi_mode;
   std::string full_url;
   JsonManifest::ErrorInfo error_info;
-  if (it->second->GetProgramURL(&full_url, pnacl_options, &uses_nonsfi_mode,
-                                &error_info)) {
+  if (manifest->GetProgramURL(&full_url, pnacl_options, &uses_nonsfi_mode,
+                              &error_info)) {
     *pp_full_url = ppapi::StringVar::StringToPPVar(full_url);
     *pp_uses_nonsfi_mode = PP_FromBool(uses_nonsfi_mode);
     return PP_TRUE;
   }
 
   if (load_manager)
     load_manager->ReportLoadError(error_info.error, error_info.string);
   return PP_FALSE;
 }
 
@@ skipping 26 matching lines @@
           FROM_HERE,
           base::Bind(callback.func, callback.user_data,
                      static_cast<int32_t>(PP_ERROR_FAILED)));
       return;
     }
     std::string key_basename = key_string.substr(kFilesPrefix.length());
     resolved_url =
         std::string(kPNaClTranslatorBaseUrl) + GetSandboxArch() + "/" +
         key_basename;
   } else {
-    JsonManifestMap::iterator it = g_manifest_map.Get().find(instance);
-    if (it == g_manifest_map.Get().end()) {
+    JsonManifest* manifest = GetJsonManifest(instance);
+    if (manifest == NULL) {
       ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
           FROM_HERE,
           base::Bind(callback.func, callback.user_data,
                      static_cast<int32_t>(PP_ERROR_FAILED)));
       return;
     }
 
     PP_PNaClOptions pnacl_options;
-    bool ok = it->second->ResolveKey(key, &resolved_url, &pnacl_options);
+    bool ok = manifest->ResolveKey(key, &resolved_url, &pnacl_options);
     // We don't support OpenManifestEntry for files that require PNaCl
     // translation.
     if (!ok || pnacl_options.translate) {
       ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
           FROM_HERE,
           base::Bind(callback.func, callback.user_data,
                      static_cast<int32_t>(PP_ERROR_FAILED)));
       return;
     }
   }
@@ skipping 452 matching lines @@
   &DownloadNexe,
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl