Make content::ResourceContext be a real interface like the rest of the Content API (i.e. don't ha...

content/browser/plugin_service_impl.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.
 
 #include "content/browser/plugin_service_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
@@ skipping 275 matching lines @@
     return plugin_host;
 
   // Validate that the plugin is actually registered.
   content::PepperPluginInfo* info = GetRegisteredPpapiPluginInfo(plugin_path);
   if (!info)
     return NULL;
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   return PpapiPluginProcessHost::CreatePluginHost(
       *info,
-      client->GetResourceContext()->host_resolver());
+      client->GetResourceContext()->GetHostResolver());
 }
 
 PpapiPluginProcessHost* PluginServiceImpl::FindOrStartPpapiBrokerProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PpapiPluginProcessHost* plugin_host = FindPpapiBrokerProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
@@ skipping 18 matching lines @@
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.insert(client);
 
   // Make sure plugins are loaded if necessary.
   content::PluginServiceFilterParams params = {
     render_process_id,
     render_view_id,
     page_url,
-    &client->GetResourceContext()
+    client->GetResourceContext()
   };
   GetPlugins(base::Bind(
       &PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin,
       base::Unretained(this), params, url, mime_type, client));
 }
 
 void PluginServiceImpl::OpenChannelToPpapiPlugin(
     const FilePath& path,
     PpapiPluginProcessHost::PluginClient* client) {
   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiPluginProcess(
@@ skipping 32 matching lines @@
       params.resource_context);
 }
 
 void PluginServiceImpl::GetAllowedPluginForOpenChannelToPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
-    const content::ResourceContext* resource_context) {
+    content::ResourceContext* resource_context) {
   webkit::WebPluginInfo info;
   bool allow_wildcard = true;
   bool found = GetPluginInfo(
-      render_process_id, render_view_id, *resource_context,
+      render_process_id, render_view_id, resource_context,
       url, page_url, mime_type, allow_wildcard,
       NULL, &info, NULL);
   FilePath plugin_path;
   if (found)
     plugin_path = info.path;
 
   // Now we jump back to the IO thread to finish opening the channel.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&PluginServiceImpl::FinishOpenChannelToPlugin,
@@ skipping 26 matching lines @@
     std::vector<webkit::WebPluginInfo>* plugins,
     std::vector<std::string>* actual_mime_types) {
   bool use_stale = false;
   plugin_list_->GetPluginInfoArray(url, mime_type, allow_wildcard,
                                    &use_stale, plugins, actual_mime_types);
   return use_stale;
 }
 
 bool PluginServiceImpl::GetPluginInfo(int render_process_id,
                                       int render_view_id,
-                                      const content::ResourceContext& context,
+                                      content::ResourceContext* context,
                                       const GURL& url,
                                       const GURL& page_url,
                                       const std::string& mime_type,
                                       bool allow_wildcard,
                                       bool* is_stale,
                                       webkit::WebPluginInfo* info,
                                       std::string* actual_mime_type) {
   std::vector<webkit::WebPluginInfo> plugins;
   std::vector<std::string> mime_types;
   bool stale = GetPluginInfoArray(
       url, mime_type, allow_wildcard, &plugins, &mime_types);
   if (is_stale)
     *is_stale = stale;
 
   for (size_t i = 0; i < plugins.size(); ++i) {
     if (!filter_ || filter_->ShouldUsePlugin(render_process_id,
                                              render_view_id,
-                                             &context,
+                                             context,
                                              url,
                                              page_url,
                                              &plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
@@ skipping 189 matching lines @@
   plugin_list_->RegisterInternalPlugin(info, add_at_beginning);
 }
 
 string16 PluginServiceImpl::GetPluginGroupName(const std::string& plugin_name) {
   return plugin_list_->GetPluginGroupName(plugin_name);
 }
 
 webkit::npapi::PluginList* PluginServiceImpl::GetPluginList() {
   return plugin_list_;
 }