Pepper: Manifest ID cleanup.

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 84 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<int32_t, nacl::JsonManifest> JsonManifestMap;
+typedef base::ScopedPtrHashMap<PP_Instance, nacl::JsonManifest> JsonManifestMap;
 
 base::LazyInstance<JsonManifestMap> g_manifest_map =
     LAZY_INSTANCE_INITIALIZER;
 
-base::LazyInstance<int32_t> g_next_manifest_id =
-    LAZY_INSTANCE_INITIALIZER;
-
-// We have to define a method here since we can't use a static initializer.
-int32_t GetPNaClManifestId() {
-  return std::numeric_limits<int32_t>::max();
-}
-
 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 611 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);
+
   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 66 matching lines @@
 
 int64_t GetNexeSize(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (load_manager)
     return load_manager->nexe_size();
   return 0;
 }
 
 void DownloadManifestToBuffer(PP_Instance instance,
-                              int32_t* out_manifest_id,
                               struct PP_CompletionCallback callback);
 
-int32_t CreateJsonManifest(PP_Instance instance,
-                           const std::string& manifest_url,
-                           const std::string& manifest_data);
+bool CreateJsonManifest(PP_Instance instance,
+                        const std::string& manifest_url,
+                        const std::string& manifest_data);
 
 void RequestNaClManifest(PP_Instance instance,
                          const char* url,
-                         int32_t* out_manifest_id,
                          PP_CompletionCallback callback) {
   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;
   }
 
   if (!load_manager->RequestNaClManifest(url)) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   const GURL& base_url = load_manager->manifest_base_url();
   if (base_url.SchemeIs("data")) {
     GURL gurl(base_url);
     std::string mime_type;
     std::string charset;
     std::string data;
     int32_t error = PP_ERROR_FAILED;
     if (net::DataURL::Parse(gurl, &mime_type, &charset, &data)) {
       if (data.size() <= ManifestDownloader::kNaClManifestMaxFileBytes) {
-        error = PP_OK;
-        *out_manifest_id = CreateJsonManifest(instance, base_url.spec(), data);
+        if (CreateJsonManifest(instance, base_url.spec(), data))
+          error = PP_OK;
       } else {
         load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_TOO_LARGE,
                                       "manifest file too large.");
       }
     } else {
       load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_LOAD_URL,
                                     "could not load manifest url.");
     }
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback.func, callback.user_data, error));
   } else {
-    DownloadManifestToBuffer(instance, out_manifest_id, callback);
+    DownloadManifestToBuffer(instance, callback);
   }
 }
 
 PP_Var GetManifestBaseURL(PP_Instance 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())
@@ skipping 18 matching lines @@
 
 PP_Bool DevInterfacesEnabled(PP_Instance 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,
-                                        int32_t* out_manifest_id,
                                         base::Time start_time,
                                         PP_NaClError pp_nacl_error,
                                         const std::string& data);
 
 void DownloadManifestToBuffer(PP_Instance instance,
-                              int32_t* out_manifest_id,
                               struct PP_CompletionCallback callback) {
   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 =
       plugin_instance->GetContainer()->element().document();
 
   const GURL& gurl = load_manager->manifest_base_url();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   blink::WebURLRequest request = CreateWebURLRequest(document, gurl);
 
   // ManifestDownloader deletes itself after invoking the callback.
   ManifestDownloader* manifest_downloader = new ManifestDownloader(
       url_loader.Pass(),
       load_manager->is_installed(),
       base::Bind(DownloadManifestToBufferCompletion,
-                 instance, callback, out_manifest_id, base::Time::Now()));
+                 instance, callback, base::Time::Now()));
   manifest_downloader->Load(request);
 }
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
-                                        int32_t* out_manifest_id,
                                         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);
   if (!load_manager) {
     callback.func(callback.user_data, PP_ERROR_ABORTED);
@@ skipping 22 matching lines @@
       break;
     default:
       NOTREACHED();
       pp_error = PP_ERROR_FAILED;
       load_manager->ReportLoadError(PP_NACL_ERROR_MANIFEST_LOAD_URL,
                                     "could not load manifest url.");
   }
 
   if (pp_error == PP_OK) {
     std::string base_url = load_manager->manifest_base_url().spec();
-    *out_manifest_id = CreateJsonManifest(instance, base_url, data);
+    if (!CreateJsonManifest(instance, base_url, data))
+      pp_error = PP_ERROR_FAILED;
   }
   callback.func(callback.user_data, pp_error);
 }
 
-int32_t CreatePNaClManifest(PP_Instance /* instance */) {
-  return GetPNaClManifestId();
-}
-
-int32_t CreateJsonManifest(PP_Instance instance,
-                           const std::string& manifest_url,
-                           const std::string& manifest_data) {
+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);
   if (!load_manager)
-    return -1;
-  int32_t manifest_id = g_next_manifest_id.Get();
-  g_next_manifest_id.Get()++;
+    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)) {
-    g_manifest_map.Get().add(manifest_id, j.Pass());
-    return manifest_id;
+    g_manifest_map.Get().add(instance, j.Pass());
+    return true;
   }
   load_manager->ReportLoadError(error_info.error, error_info.string);
-  return -1;
-}
-
-void DestroyManifest(PP_Instance /* instance */,
-                     int32_t manifest_id) {
-  if (manifest_id == GetPNaClManifestId())
-    return;
-  g_manifest_map.Get().erase(manifest_id);
+  return false;
 }
 
 PP_Bool ManifestGetProgramURL(PP_Instance instance,
-                              int32_t manifest_id,
                               PP_Var* pp_full_url,
                               PP_PNaClOptions* pnacl_options,
                               PP_Bool* pp_uses_nonsfi_mode) {
   nacl::NexeLoadManager* load_manager = GetNexeLoadManager(instance);
-  if (manifest_id == GetPNaClManifestId()) {
-    if (load_manager) {
-      load_manager->ReportLoadError(
-          PP_NACL_ERROR_MANIFEST_GET_NEXE_URL,
-          "pnacl manifest does not contain a program.");
-    }
-    return PP_FALSE;
-  }
 
-  JsonManifestMap::iterator it = g_manifest_map.Get().find(manifest_id);
+  JsonManifestMap::iterator it = g_manifest_map.Get().find(instance);
   if (it == g_manifest_map.Get().end())
     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)) {
     *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;
 }
 
 PP_Bool ManifestResolveKey(PP_Instance instance,
-                           int32_t manifest_id,
+                           PP_Bool is_helper_process,
                            const char* key,
                            PP_Var* pp_full_url,
                            PP_PNaClOptions* pnacl_options) {
-  if (manifest_id == GetPNaClManifestId()) {
+  // For "helper" processes (llc and ld), we resolve keys manually as there is
+  // no existing .nmf file to parse.
+  if (PP_ToBool(is_helper_process)) {
     pnacl_options->translate = PP_FALSE;
     // We can only resolve keys in the files/ namespace.
     const std::string kFilesPrefix = "files/";
     std::string key_string(key);
     if (key_string.find(kFilesPrefix) == std::string::npos) {
       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 PP_FALSE;
     }
     std::string key_basename = key_string.substr(kFilesPrefix.length());
     std::string pnacl_url =
         std::string("chrome://pnacl-translator/") + GetSandboxArch() + "/" +
         key_basename;
     *pp_full_url = ppapi::StringVar::StringToPPVar(pnacl_url);
     return PP_TRUE;
   }
 
-  JsonManifestMap::iterator it = g_manifest_map.Get().find(manifest_id);
+  JsonManifestMap::iterator it = g_manifest_map.Get().find(instance);
   if (it == g_manifest_map.Get().end())
     return PP_FALSE;
 
   std::string full_url;
   bool ok = it->second->ResolveKey(key, &full_url, pnacl_options);
   if (ok)
     *pp_full_url = ppapi::StringVar::StringToPPVar(full_url);
   return PP_FromBool(ok);
 }
 
@@ skipping 410 matching lines @@
   &GetExitStatus,
   &SetExitStatus,
   &Vlog,
   &InitializePlugin,
   &GetNexeSize,
   &RequestNaClManifest,
   &GetManifestBaseURL,
   &ProcessNaClManifest,
   &GetManifestURLArgument,
   &DevInterfacesEnabled,
-  &CreatePNaClManifest,
-  &DestroyManifest,
   &ManifestGetProgramURL,
   &ManifestResolveKey,
   &GetPNaClResourceInfo,
   &GetCpuFeatureAttrs,
   &PostMessageToJavaScript,
   &DownloadNexe,
   &DownloadFile
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl