This adds a plugin selection policy for selecting allowed plugins

chrome/browser/plugin_service.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include "chrome/browser/plugin_service.h"
 
 #include "base/command_line.h"
 #include "base/path_service.h"
@@ skipping 22 matching lines @@
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pepper_plugin_registry.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #ifndef DISABLE_NACL
 #include "native_client/src/trusted/plugin/nacl_entry_points.h"
 #endif
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_list.h"
+#include "webkit/glue/plugins/webplugininfo.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/plugin_selection_policy.h"
+#endif
 
 #if defined(OS_MACOSX)
 static void NotifyPluginsOfActivation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::PLUGIN_PROCESS);
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     plugin->OnAppActivation();
   }
@@ skipping 63 matching lines @@
       PathService::Get(chrome::FILE_FLASH_PLUGIN, &path)) {
     NPAPI::PluginList::Singleton()->AddExtraPluginPath(path);
   }
 
 #ifndef DISABLE_NACL
   if (command_line->HasSwitch(switches::kInternalNaCl)) {
     RegisterInternalNaClPlugin();
   }
 #endif
 
+#if defined(OS_CHROMEOS)
+  plugin_selection_policy_ = new chromeos::PluginSelectionPolicy;
+  plugin_selection_policy_->StartInit();
+#endif
+
   chrome::RegisterInternalGPUPlugin();
 
 #if defined(OS_WIN)
   hkcu_key_.Create(
       HKEY_CURRENT_USER, kRegistryMozillaPlugins, KEY_NOTIFY);
   hklm_key_.Create(
       HKEY_LOCAL_MACHINE, kRegistryMozillaPlugins, KEY_NOTIFY);
   if (hkcu_key_.StartWatching()) {
     hkcu_event_.reset(new base::WaitableEvent(hkcu_key_.watch_event()));
     hkcu_watcher_.StartWatching(hkcu_event_.get(), this);
@@ skipping 100 matching lines @@
     return NULL;
   }
 
   return plugin_host;
 }
 
 void PluginService::OpenChannelToPlugin(
     ResourceMessageFilter* renderer_msg_filter,
     const GURL& url,
     const std::string& mime_type,
-    const std::string& locale,
+    IPC::Message* reply_msg) {
+  // The PluginList::GetFirstAllowedPluginInfo may need to load the
+  // plugins.  Don't do it on the IO thread.
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          this, &PluginService::GetAllowedPluginForOpenChannelToPlugin,
+          renderer_msg_filter, url, mime_type, reply_msg));
+}
+
+void PluginService::GetAllowedPluginForOpenChannelToPlugin(
+    ResourceMessageFilter* renderer_msg_filter,
+    const GURL& url,
+    const std::string& mime_type,
+    IPC::Message* reply_msg) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  WebPluginInfo info;
+  bool found = GetFirstAllowedPluginInfo(url, mime_type, &info, NULL);
+  FilePath plugin_path;
+  if (found && info.enabled)
+    plugin_path = FilePath(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,
+          renderer_msg_filter, mime_type, plugin_path, reply_msg));
+}
+
+void PluginService::FinishOpenChannelToPlugin(
+    ResourceMessageFilter* renderer_msg_filter,
+    const std::string& mime_type,
+    const FilePath& plugin_path,
     IPC::Message* reply_msg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  bool allow_wildcard = true;
-  WebPluginInfo info;
-  FilePath plugin_path;
-  if (NPAPI::PluginList::Singleton()->GetPluginInfo(
-          url, mime_type, allow_wildcard, &info, NULL) && info.enabled) {
-    plugin_path = info.path;
-  }
-
   PluginProcessHost* plugin_host = FindOrStartPluginProcess(plugin_path);
   if (plugin_host) {
     plugin_host->OpenChannelToPlugin(renderer_msg_filter, mime_type, reply_msg);
   } else {
     PluginProcessHost::ReplyToRenderer(
         renderer_msg_filter, IPC::ChannelHandle(), WebPluginInfo(), reply_msg);
   }
 }
 
+bool PluginService::GetFirstAllowedPluginInfo(
+    const GURL& url,
+    const std::string& mime_type,
+    WebPluginInfo* info,
+    std::string* actual_mime_type) {
+  // GetPluginInfoArray may need to load the plugins, so we need to be
+  // on the FILE thread.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  bool allow_wildcard = true;
+#if defined(OS_CHROMEOS)
+  std::vector<WebPluginInfo> info_array;
+  std::vector<std::string> actual_mime_types;
+  NPAPI::PluginList::Singleton()->GetPluginInfoArray(
+      url, mime_type, allow_wildcard, &info_array, &actual_mime_types);
+
+  // Now we filter by the plugin selection policy.
+  int allowed_index = plugin_selection_policy_->FindFirstAllowed(url,
+                                                                 info_array);
+  if (!info_array.empty() && allowed_index >= 0) {
+    *info = info_array[allowed_index];
+    if (actual_mime_type)
+      *actual_mime_type = actual_mime_types[allowed_index];
+    return true;
+  }
+  return false;
+#else
+  return NPAPI::PluginList::Singleton()->GetPluginInfo(
+      url, mime_type, allow_wildcard, info, actual_mime_type);
+#endif
+}
+
 static void PurgePluginListCache(bool reload_pages) {
   for (RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Send(new ViewMsg_PurgePluginListCache(reload_pages));
   }
 }
 
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
@@ skipping 102 matching lines @@
     info.mime_types = ASCIIToWide(JoinString(plugins[i].mime_types, '|'));
 
     // These NPAPI entry points will never be called.  TODO(darin): Come up
     // with a cleaner way to register pepper plugins with the NPAPI PluginList,
     // or perhaps refactor the PluginList to be less specific to NPAPI.
     memset(&info.entry_points, 0, sizeof(info.entry_points));
 
     NPAPI::PluginList::Singleton()->RegisterInternalPlugin(info);
   }
 }