Use a proper profile in NaClBrowserDelegateImpl::MapUrlToLocalFilePath

chrome/browser/nacl_host/nacl_browser_delegate_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 "chrome/browser/nacl_host/nacl_browser_delegate_impl.h"
 
 #include "base/path_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/pnacl/pnacl_component_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/nacl_host/nacl_infobar_delegate.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/logging_chrome.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/site_instance.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/info_map.h"
@@ skipping 72 matching lines @@
   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                    base::Bind(&OnKeepaliveOnUIThread,
                                               instance_data,
                                               profile_data_directory));
 }
 
 }  // namespace
 
 NaClBrowserDelegateImpl::NaClBrowserDelegateImpl(
-    extensions::InfoMap* extension_info_map)
-    : extension_info_map_(extension_info_map), inverse_debug_patterns_(false) {}
+    ProfileManager* profile_manager)
+    : profile_manager_(profile_manager), inverse_debug_patterns_(false) {
+  DCHECK(profile_manager_);
+}
 
 NaClBrowserDelegateImpl::~NaClBrowserDelegateImpl() {
 }
 
 void NaClBrowserDelegateImpl::ShowMissingArchInfobar(int render_process_id,
                                                      int render_view_id) {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&NaClInfoBarDelegate::Create, render_process_id,
                  render_view_id));
@@ skipping 77 matching lines @@
   if (inverse_debug_patterns_) {
     return !matches;
   } else {
     return matches;
   }
 }
 
 // This function is security sensitive.  Be sure to check with a security
 // person before you modify it.
 bool NaClBrowserDelegateImpl::MapUrlToLocalFilePath(
-    const GURL& file_url, bool use_blocking_api, base::FilePath* file_path) {
-  DCHECK(extension_info_map_);
+    const GURL& file_url,
+    bool use_blocking_api,
+    const base::FilePath& profile_directory,
+    base::FilePath* file_path) {
+  // Get the profile associated with the renderer.
+  Profile* profile = profile_manager_->GetProfileByPath(profile_directory);
+  if (!profile)
+    return false;
+
+  scoped_refptr<extensions::InfoMap> extension_info_map =
+      extensions::ExtensionSystem::Get(profile)->info_map();
+  DCHECK(extension_info_map);
+
   // Check that the URL is recognized by the extension system.
   const extensions::Extension* extension =
-      extension_info_map_->extensions().GetExtensionOrAppByURL(file_url);
+      extension_info_map->extensions().GetExtensionOrAppByURL(file_url);
   if (!extension)
     return false;
 
   // This is a short-cut which avoids calling a blocking file operation
   // (GetFilePath()), so that this can be called on the IO thread. It only
   // handles a subset of the urls.
   if (!use_blocking_api) {
     if (file_url.SchemeIs(extensions::kExtensionScheme)) {
       std::string path = file_url.path();
       base::TrimString(path, "/", &path);  // Remove first slash
       *file_path = extension->path().AppendASCII(path);
       return true;
     }
     return false;
   }
 
   std::string path = file_url.path();
   extensions::ExtensionResource resource;
 
   if (SharedModuleInfo::IsImportedPath(path)) {
     // Check if this is a valid path that is imported for this extension.
     std::string new_extension_id;
     std::string new_relative_path;
     SharedModuleInfo::ParseImportedPath(path, &new_extension_id,
                                         &new_relative_path);
     const extensions::Extension* new_extension =
-        extension_info_map_->extensions().GetByID(new_extension_id);
+        extension_info_map->extensions().GetByID(new_extension_id);
     if (!new_extension)
       return false;
 
     if (!SharedModuleInfo::ImportsExtensionById(extension, new_extension_id) ||
         !SharedModuleInfo::IsExportAllowed(new_extension, new_relative_path)) {
       return false;
     }
 
     resource = new_extension->GetResource(new_relative_path);
   } else {
@@ skipping 10 matching lines @@
     return false;
 
   *file_path = resource_file_path;
   return true;
 }
 
 content::BrowserPpapiHost::OnKeepaliveCallback
 NaClBrowserDelegateImpl::GetOnKeepaliveCallback() {
   return base::Bind(&OnKeepalive);
 }