When we detect a PDF with an unsupported feature, ask the user if they want t...

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 "chrome/browser/plugin_service.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chrome_plugin_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/plugin_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
+#include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/default_plugin.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/gpu_plugin.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pepper_plugin_registry.h"
@@ skipping 171 matching lines @@
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
 #if defined(OS_MACOSX)
   // We need to know when the browser comes forward so we can bring modal plugin
   // windows forward too.
   registrar_.Add(this, NotificationType::APP_ACTIVATED,
                  NotificationService::AllSources());
 #endif
   registrar_.Add(this, NotificationType::PLUGIN_ENABLE_STATUS_CHANGED,
                  NotificationService::AllSources());
+  registrar_.Add(this,
+                 NotificationType::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();
   hkcu_event_->Release();
   hklm_event_->Release();
 #endif
@@ skipping 52 matching lines @@
   scoped_ptr<PluginProcessHost> new_host(new PluginProcessHost());
   if (!new_host->Init(info, ui_locale_)) {
     NOTREACHED();  // Init is not expected to fail
     return NULL;
   }
 
   return new_host.release();
 }
 
 void PluginService::OpenChannelToPlugin(
+    int render_process_id,
+    int render_view_id,
     const GURL& url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
   // 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,
-          url, mime_type, client));
+          render_process_id, render_view_id, url, mime_type, client));
 }
 
 void PluginService::GetAllowedPluginForOpenChannelToPlugin(
+    int render_process_id,
+    int render_view_id,
     const GURL& url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   webkit::npapi::WebPluginInfo info;
-  bool found = GetFirstAllowedPluginInfo(url, mime_type, &info, NULL);
+  bool found = GetFirstAllowedPluginInfo(
+      render_process_id, render_view_id, 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,
           plugin_path, client));
 }
 
 void PluginService::FinishOpenChannelToPlugin(
     const FilePath& plugin_path,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PluginProcessHost* plugin_host = FindOrStartPluginProcess(plugin_path);
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else
     client->OnError();
 }
 
 bool PluginService::GetFirstAllowedPluginInfo(
+    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) {
   // 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<webkit::npapi::WebPluginInfo> info_array;
   std::vector<std::string> actual_mime_types;
   webkit::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
+  {
+    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) {
+        *actual_mime_type = mime_type;
+        *info = overridden_plugins_[i].plugin;
+        return true;
+      }
+    }
+  }
   return webkit::npapi::PluginList::Singleton()->GetPluginInfo(
       url, mime_type, allow_wildcard, info, actual_mime_type);
 #endif
 }
 
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
@@ skipping 62 matching lines @@
       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                               NewRunnableFunction(&NotifyPluginsOfActivation));
       break;
     }
 #endif
 
     case NotificationType::PLUGIN_ENABLE_STATUS_CHANGED: {
       PurgePluginListCache(false);
       break;
     }
+    case NotificationType::RENDERER_PROCESS_CLOSED: {
+      int render_process_id = Source<RenderProcessHost>(source).ptr()->id();
+
+      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();
   }
 }
 
 bool PluginService::PrivatePluginAllowedForURL(const FilePath& plugin_path,
                                                const GURL& url) {
   if (url.is_empty())
     return true;  // Caller wants all plugins.
 
   PrivatePluginMap::iterator it = private_plugins_.find(plugin_path);
   if (it == private_plugins_.end())
     return true;  // This plugin is not private, so it's allowed everywhere.
 
   // We do a dumb compare of scheme and host, rather than using the domain
   // service, since we only care about this for extensions.
   const GURL& required_url = it->second;
   return (url.scheme() == required_url.scheme() &&
           url.host() == required_url.host());
 }
 
+void PluginService::OverridePluginForTab(OverriddenPlugin plugin) {
+  AutoLock auto_lock(overridden_plugins_lock_);
+  overridden_plugins_.push_back(plugin);
+}
+
 void PluginService::RegisterPepperPlugins() {
   std::vector<PepperPluginInfo> plugins;
   PepperPluginRegistry::GetList(&plugins);
   for (size_t i = 0; i < plugins.size(); ++i) {
     webkit::npapi::WebPluginInfo info;
     info.path = plugins[i].path;
     info.name = plugins[i].name.empty() ?
         WideToUTF16(plugins[i].path.BaseName().ToWStringHack()) :
         ASCIIToUTF16(plugins[i].name);
     info.desc = ASCIIToUTF16(plugins[i].description);
@@ skipping 18 matching lines @@
 #if defined(OS_LINUX)
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif