Implement chrome://plugins page that can disable plugins.

webkit/glue/plugins/plugin_list.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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 "webkit/glue/plugins/plugin_list.h"
 
+#include <algorithm>
+
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/time.h"
 #include "net/base/mime_util.h"
 #include "webkit/default_plugin/plugin_main.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/webkit_glue.h"
@@ skipping 82 matching lines @@
 
   info->mime_types.clear();
 
   if (mime_types.empty())
     return false;
 
   info->name = pvi.product_name;
   info->desc = pvi.file_description;
   info->version = pvi.file_version;
   info->path = pvi.path;
+  info->enabled = true;
 
   for (size_t i = 0; i < mime_types.size(); ++i) {
     WebPluginMimeType mime_type;
     mime_type.mime_type = StringToLowerASCII(mime_types[i]);
     if (file_extensions.size() > i)
       SplitString(file_extensions[i], ',', &mime_type.file_extensions);
 
     if (descriptions.size() > i) {
       mime_type.description = descriptions[i];
 
@@ skipping 88 matching lines @@
   }
 
   // Load the default plugin last.
   if (webkit_glue::IsDefaultPluginEnabled())
     LoadPlugin(FilePath(kDefaultPluginLibraryName), &new_plugins);
 
   base::TimeTicks end_time = base::TimeTicks::Now();
   base::TimeDelta elapsed = end_time - start_time;
   DLOG(INFO) << "Loaded plugin list in " << elapsed.InMilliseconds() << " ms.";
 
+  // Only update the data now since loading plugins can take a while.
   AutoLock lock(lock_);
+
+  // Go through and mark new plugins in the disabled list as, well, disabled.
+  for (std::vector<WebPluginInfo>::iterator it = new_plugins.begin();
+       it != new_plugins.end();
+       ++it) {
+    if (disabled_plugins_.find(it->path) != disabled_plugins_.end())
+      it->enabled = false;
+  }
+
   plugins_ = new_plugins;
   plugins_loaded_ = true;
 }
 
 void PluginList::LoadPlugin(const FilePath& path,
                             std::vector<WebPluginInfo>* plugins) {
   WebPluginInfo plugin_info;
   const PluginEntryPoints* entry_points;
 
   if (!ReadPluginInfo(path, &plugin_info, &entry_points))
@@ skipping 96 matching lines @@
 }
 
 
 void PluginList::GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins) {
   LoadPlugins(refresh);
 
   AutoLock lock(lock_);
   *plugins = plugins_;
 }
 
+void PluginList::GetEnabledPlugins(bool refresh,
+                                   std::vector<WebPluginInfo>* plugins) {
+  LoadPlugins(refresh);
+
+  plugins->clear();
+  AutoLock lock(lock_);
+  for (std::vector<WebPluginInfo>::const_iterator it = plugins_.begin();
+       it != plugins_.end();
+       ++it) {
+    if (it->enabled)
+      plugins->push_back(*it);
+  }
+}
+
 bool PluginList::GetPluginInfo(const GURL& url,
                                const std::string& mime_type,
                                bool allow_wildcard,
                                WebPluginInfo* info,
                                std::string* actual_mime_type) {
   bool found = FindPlugin(mime_type, allow_wildcard, info);
   if (!found || (info->path.value() == kDefaultPluginLibraryName)) {
     WebPluginInfo info2;
     if (FindPlugin(url, actual_mime_type, &info2)) {
       found = true;
@@ skipping 11 matching lines @@
   for (size_t i = 0; i < plugins_.size(); ++i) {
     if (plugins_[i].path == plugin_path) {
       *info = plugins_[i];
       return true;
     }
   }
 
   return false;
 }
 
+bool PluginList::EnablePlugin(const FilePath& filename) {
+  AutoLock lock(lock_);
+
+  bool did_enable = false;
+
+  std::set<FilePath>::iterator entry = disabled_plugins_.find(filename);
+  if (entry == disabled_plugins_.end())
+    return did_enable;  // Early exit if plugin not in disabled list.
+
+  disabled_plugins_.erase(entry);  // Remove from disabled list.
+
+  // Set enabled flags if necessary.
+  for (std::vector<WebPluginInfo>::iterator it = plugins_.begin();
+       it != plugins_.end();
+       ++it) {
+    if (it->path == filename) {
+      DCHECK(!it->enabled);  // Should have been disabled.
+      it->enabled = true;
+      did_enable = true;
+    }
+  }
+
+  return did_enable;
+}
+
+bool PluginList::DisablePlugin(const FilePath& filename) {
+  AutoLock lock(lock_);
+
+  bool did_disable = false;
+
+  if (disabled_plugins_.find(filename) != disabled_plugins_.end())
+    return did_disable;  // Early exit if plugin already in disabled list.
+
+  disabled_plugins_.insert(filename);  // Add to disabled list.
+
+  // Unset enabled flags if necessary.
+  for (std::vector<WebPluginInfo>::iterator it = plugins_.begin();
+       it != plugins_.end();
+       ++it) {
+    if (it->path == filename) {
+      DCHECK(it->enabled);  // Should have been enabled.
+      it->enabled = false;
+      did_disable = true;
+    }
+  }
+
+  return did_disable;
+}
+
 void PluginList::Shutdown() {
   // TODO
 }
 
 }  // namespace NPAPI