Pepper: Remove url_info_map from trusted plugin.

ppapi/native_client/src/trusted/plugin/plugin.cc

 // Copyright (c) 2012 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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 355 matching lines @@
 
 
 Plugin::~Plugin() {
   int64_t shutdown_start = NaClGetTimeOfDayMicroseconds();
 
   PLUGIN_PRINTF(("Plugin::~Plugin (this=%p)\n",
                  static_cast<void*>(this)));
   // Destroy the coordinator while the rest of the data is still there
   pnacl_coordinator_.reset(NULL);
 
-  for (std::map<nacl::string, NaClFileInfoAutoCloser*>::iterator it =
-           url_file_info_map_.begin();
-       it != url_file_info_map_.end();
-       ++it) {
-    delete it->second;
-  }
   url_downloaders_.erase(url_downloaders_.begin(), url_downloaders_.end());
 
   // Clean up accounting for our instance inside the NaCl interface.
   if (manifest_id_ != -1)
     nacl_interface_->DestroyManifest(pp_instance(), manifest_id_);
   nacl_interface_->InstanceDestroyed(pp_instance());
 
   // ShutDownSubprocesses shuts down the main subprocess, which shuts
   // down the main ServiceRuntime object, which kills the subprocess.
   // As a side effect of the subprocess being killed, the reverse
@@ skipping 170 matching lines @@
       callback_factory_.NewCallback(&Plugin::NaClManifestFileDidOpen);
   nacl_interface_->RequestNaClManifest(pp_instance(),
                                        url.c_str(),
                                        &manifest_id_,
                                        open_callback.pp_completion_callback());
 }
 
 void Plugin::UrlDidOpenForStreamAsFile(
     int32_t pp_error,
     FileDownloader* url_downloader,
+    NaClFileInfo* out_file_info,
     pp::CompletionCallback callback) {
   PLUGIN_PRINTF(("Plugin::UrlDidOpen (pp_error=%" NACL_PRId32
                  ", url_downloader=%p)\n", pp_error,
                  static_cast<void*>(url_downloader)));
   url_downloaders_.erase(url_downloader);
   nacl::scoped_ptr<FileDownloader> scoped_url_downloader(url_downloader);
   NaClFileInfo tmp_info(scoped_url_downloader->GetFileInfo());
   NaClFileInfoAutoCloser *info = new NaClFileInfoAutoCloser(&tmp_info);
 
   if (pp_error != PP_OK) {
     callback.Run(pp_error);
     delete info;
   } else if (info->get_desc() > NACL_NO_FILE_DESC) {
-    std::map<nacl::string, NaClFileInfoAutoCloser*>::iterator it =
-        url_file_info_map_.find(url_downloader->url());
-    if (it != url_file_info_map_.end())
-      delete it->second;
-    url_file_info_map_[url_downloader->url()] = info;
+    *out_file_info = info->Release();
     callback.Run(PP_OK);
   } else {
     callback.Run(PP_ERROR_FAILED);
     delete info;
   }
 }
 
-struct NaClFileInfo Plugin::GetFileInfo(const nacl::string& url) {
-  struct NaClFileInfo info;
-  memset(&info, 0, sizeof(info));
-  std::map<nacl::string, NaClFileInfoAutoCloser*>::iterator it =
-      url_file_info_map_.find(url);
-  if (it != url_file_info_map_.end()) {
-    info = it->second->get();
-    info.desc = DUP(info.desc);
-  } else {
-    info.desc = -1;
-  }
-  return info;
-}
-
 bool Plugin::StreamAsFile(const nacl::string& url,
+                          NaClFileInfo* out_file_info,
                           const pp::CompletionCallback& callback) {
   PLUGIN_PRINTF(("Plugin::StreamAsFile (url='%s')\n", url.c_str()));
   FileDownloader* downloader = new FileDownloader();
   downloader->Initialize(this);
   url_downloaders_.insert(downloader);
 
   // Untrusted loads are always relative to the page's origin.
   if (!GetNaClInterface()->ResolvesRelativeToPluginBaseUrl(pp_instance(),
                                                            url.c_str()))
     return false;
 
   // Try the fast path first. This will only block if the file is installed.
   if (OpenURLFast(url, downloader)) {
-    UrlDidOpenForStreamAsFile(PP_OK, downloader, callback);
+    UrlDidOpenForStreamAsFile(PP_OK, downloader, out_file_info, callback);
     return true;
   }
 
   pp::CompletionCallback open_callback = callback_factory_.NewCallback(
-      &Plugin::UrlDidOpenForStreamAsFile, downloader, callback);
+      &Plugin::UrlDidOpenForStreamAsFile, downloader, out_file_info, callback);
   // If true, will always call the callback on success or failure.
   return downloader->Open(url,
                           DOWNLOAD_TO_FILE,
                           open_callback,
                           true,
                           &UpdateDownloadProgress);
 }
 
 
 void Plugin::ReportLoadSuccess(uint64_t loaded_bytes, uint64_t total_bytes) {
@@ skipping 127 matching lines @@
 
 void Plugin::SetExitStatusOnMainThread(int32_t pp_error,
                                        int exit_status) {
   DCHECK(pp::Module::Get()->core()->IsMainThread());
   DCHECK(nacl_interface_);
   nacl_interface_->SetExitStatus(pp_instance(), exit_status);
 }
 
 
 }  // namespace plugin