Add PluginServiceFilter interface.

content/browser/plugin_service.cc

 // Copyright (c) 2011 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.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/ppapi_plugin_process_host.h"
 #include "content/browser/renderer_host/render_process_host.h"
@@ skipping 106 matching lines @@
     FilePathWatcher* watcher = new FilePathWatcher();
     VLOG(1) << "Watching for changes in: " << plugin_dirs[i].value();
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableFunction(
             &PluginService::RegisterFilePathWatcher,
             watcher, plugin_dirs[i], file_watcher_delegate_));
     file_watchers_.push_back(watcher);
   }
 #endif
-  registrar_.Add(this, content::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED,
-                 NotificationService::AllSources());
-  registrar_.Add(this,
-                 content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
-                 NotificationService::AllSources());
 }
 
 PluginService::~PluginService() {
 #if defined(OS_WIN)
   // Release the events since they're owned by RegKey, not WaitableEvent.
   hkcu_watcher_.StopWatching();
   hklm_watcher_.StopWatching();
   if (hkcu_event_.get())
     hkcu_event_->Release();
   if (hklm_event_.get())
@@ skipping 121 matching lines @@
     NOTREACHED();  // Init is not expected to fail.
     return NULL;
   }
   return new_host.release();
 }
 
 void PluginService::OpenChannelToNpapiPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
+    const GURL& policy_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  Filter* filter = content::GetContentClient()->browser()->CreatePluginFilter(
+      render_process_id, render_view_id, *client->GetResourceContext(),
+      url, policy_url);
   // The PluginList::GetPluginInfo may need to load the plugins.  Don't do it on
   // the IO thread.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this, &PluginService::GetAllowedPluginForOpenChannelToPlugin,
-          render_process_id, render_view_id, url, mime_type, client));
+          url, mime_type, filter, client));
 }
 
 void PluginService::OpenChannelToPpapiPlugin(
     const FilePath& path,
     PpapiPluginProcessHost::Client* client) {
   PpapiPluginProcessHost* plugin_host = FindOrStartPpapiPluginProcess(
       path, client);
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else  // Send error.
     client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
 }
 
 void PluginService::OpenChannelToPpapiBroker(
     const FilePath& path,
     PpapiBrokerProcessHost::Client* client) {
   PpapiBrokerProcessHost* plugin_host = FindOrStartPpapiBrokerProcess(path);
   if (plugin_host)
     plugin_host->OpenChannelToPpapiBroker(client);
   else  // Send error.
     client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
 }
 
 void PluginService::GetAllowedPluginForOpenChannelToPlugin(
-    int render_process_id,
-    int render_view_id,
     const GURL& url,
     const std::string& mime_type,
+    Filter* filter,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   webkit::npapi::WebPluginInfo info;
-  bool found = GetPluginInfo(
-      render_process_id, render_view_id, url, mime_type, &info, NULL);
+  bool allow_wildcard = true;
+  bool found = GetPluginInfo(url, mime_type, allow_wildcard, filter,
+                             NULL, &info, NULL);
   FilePath plugin_path;
   if (found)
-    plugin_path = FilePath(info.path);
+    plugin_path = info.path;
 
   // Now we jump back to the IO thread to finish opening the channel.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this, &PluginService::FinishOpenChannelToPlugin,
           plugin_path, client));
 }
 
 void PluginService::FinishOpenChannelToPlugin(
     const FilePath& plugin_path,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PluginProcessHost* plugin_host = FindOrStartNpapiPluginProcess(plugin_path);
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else
     client->OnError();
 }
 
-bool PluginService::GetPluginInfo(int render_process_id,
-                                  int render_view_id,
-                                  const GURL& url,
-                                  const std::string& mime_type,
-                                  webkit::npapi::WebPluginInfo* info,
-                                  std::string* actual_mime_type) {
+bool PluginService::GetPluginInfo(
+    const GURL& url,
+    const std::string& mime_type,
+    bool allow_wildcard,
+    Filter* filter,
+    bool* use_stale,
+    webkit::npapi::WebPluginInfo* info,
+    std::string* actual_mime_type) {
+  scoped_ptr<Filter> owned_filter(filter);
+  webkit::npapi::PluginList* plugin_list =
+      webkit::npapi::PluginList::Singleton();
   // GetPluginInfoArray may need to load the plugins, so we need to be
   // on the FILE thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  {
-    base::AutoLock auto_lock(overridden_plugins_lock_);
-    for (size_t i = 0; i < overridden_plugins_.size(); ++i) {
-      if (overridden_plugins_[i].render_process_id == render_process_id &&
-          overridden_plugins_[i].render_view_id == render_view_id &&
-          overridden_plugins_[i].url == url) {
-        if (actual_mime_type)
-          *actual_mime_type = mime_type;
-        *info = overridden_plugins_[i].plugin;
-        return true;
-      }
-    }
-  }
-  bool allow_wildcard = true;
+  DCHECK(use_stale || BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::vector<webkit::npapi::WebPluginInfo> plugins;
   std::vector<std::string> mime_types;
-  webkit::npapi::PluginList::Singleton()->GetPluginInfoArray(
-      url, mime_type, allow_wildcard, NULL, &plugins, &mime_types);
+  plugin_list->GetPluginInfoArray(
+      url, mime_type, allow_wildcard, use_stale, &plugins, &mime_types);
   for (size_t i = 0; i < plugins.size(); ++i) {
-    if (webkit::npapi::IsPluginEnabled(plugins[i])) {
+    if (filter->ShouldUsePlugin(&plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
+void PluginService::GetPlugins(
+    Filter* filter,
+    std::vector<webkit::npapi::WebPluginInfo>* plugins) {
+  scoped_ptr<Filter> owned_filter(filter);
+  webkit::npapi::PluginList* plugin_list =
+      webkit::npapi::PluginList::Singleton();
+  // GetPluginInfoArray may need to load the plugins, so we need to be
+  // on the FILE thread.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  std::vector<webkit::npapi::WebPluginInfo> all_plugins;
+  plugin_list->GetPlugins(&all_plugins);
+  for (size_t i = 0; i < all_plugins.size(); ++i) {
+    if (filter->ShouldUsePlugin(&all_plugins[i]))
+      plugins->push_back(all_plugins[i]);
+  }
+}
+
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
 
   webkit::npapi::PluginList::Singleton()->RefreshPlugins();
   PurgePluginListCache(true);
 #else
   // This event should only get signaled on a Windows machine.
   NOTREACHED();
 #endif  // defined(OS_WIN)
 }
 
 void PluginService::Observe(int type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
-  switch (type) {
 #if defined(OS_MACOSX)
-    case content::NOTIFICATION_APP_ACTIVATED: {
-      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                              NewRunnableFunction(&NotifyPluginsOfActivation));
-      break;
-    }
+  if (type == content::NOTIFICATION_APP_ACTIVATED) {
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            NewRunnableFunction(&NotifyPluginsOfActivation));
+    return;
+  }
 #endif
-
-    case content::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED: {
-      webkit::npapi::PluginList::Singleton()->RefreshPlugins();
-      PurgePluginListCache(false);
-      break;
-    }
-    case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
-      int render_process_id = Source<RenderProcessHost>(source).ptr()->id();
-
-      base::AutoLock auto_lock(overridden_plugins_lock_);
-      for (size_t i = 0; i < overridden_plugins_.size(); ++i) {
-        if (overridden_plugins_[i].render_process_id == render_process_id) {
-          overridden_plugins_.erase(overridden_plugins_.begin() + i);
-          break;
-        }
-      }
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
-}
-
-void PluginService::OverridePluginForTab(const OverriddenPlugin& plugin) {
-  base::AutoLock auto_lock(overridden_plugins_lock_);
-  overridden_plugins_.push_back(plugin);
+  NOTREACHED();
 }
 
 void PluginService::PurgePluginListCache(bool reload_pages) {
   for (RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Send(new ViewMsg_PurgePluginListCache(reload_pages));
   }
 }
 
-void PluginService::RestrictPluginToUrl(const FilePath& plugin_path,
-                                        const GURL& url) {
-  base::AutoLock auto_lock(restricted_plugin_lock_);
-  if (url.is_empty()) {
-    restricted_plugin_.erase(plugin_path);
-  } else {
-    restricted_plugin_[plugin_path] = url;
-  }
-}
-
-bool PluginService::PluginAllowedForURL(const FilePath& plugin_path,
-                                        const GURL& url) {
-  if (url.is_empty())
-    return true;  // Caller wants all plugins.
-
-  base::AutoLock auto_lock(restricted_plugin_lock_);
-
-  RestrictedPluginMap::iterator it = restricted_plugin_.find(plugin_path);
-  if (it == restricted_plugin_.end())
-    return true;  // This plugin is not restricted, so it's allowed everywhere.
-
-  const GURL& required_url = it->second;
-  return (url.scheme() == required_url.scheme() &&
-          url.host() == required_url.host());
-}
-
 void PluginService::RegisterPepperPlugins() {
   // TODO(abarth): It seems like the PepperPluginRegistry should do this work.
   PepperPluginRegistry::ComputeList(&ppapi_plugins_);
   for (size_t i = 0; i < ppapi_plugins_.size(); ++i) {
     webkit::npapi::PluginList::Singleton()->RegisterInternalPlugin(
         ppapi_plugins_[i].ToWebPluginInfo());
   }
 }
 
 // There should generally be very few plugins so a brute-force search is fine.
@@ skipping 12 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif