Revert 101269 - Store plug-in enabled/disabled state in PluginPrefs instead of WebPluginInfo, to ...

webkit/plugins/npapi/plugin_list.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 "webkit/plugins/npapi/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 212 matching lines @@
 void PluginList::RegisterInternalPlugin(const FilePath& filename,
                                         const std::string& name,
                                         const std::string& description,
                                         const std::string& mime_type_str,
                                         const PluginEntryPoints& entry_points) {
   InternalPlugin plugin;
   plugin.info.path = filename;
   plugin.info.name = ASCIIToUTF16(name);
   plugin.info.version = ASCIIToUTF16("1");
   plugin.info.desc = ASCIIToUTF16(description);
+  plugin.info.enabled = webkit::WebPluginInfo::USER_ENABLED_POLICY_UNMANAGED;
 
   webkit::WebPluginMimeType mime_type;
   mime_type.mime_type = mime_type_str;
   plugin.info.mime_types.push_back(mime_type);
 
   plugin.entry_points = entry_points;
 
   base::AutoLock lock(lock_);
   internal_plugins_.push_back(plugin);
   if (filename.value() == kDefaultPluginLibraryName)
@@ skipping 157 matching lines @@
     if (!plugins_need_refresh_)
       return;
   }
 
   ScopedVector<PluginGroup> new_plugin_groups;
   AddHardcodedPluginGroups(&new_plugin_groups);
   // Do the actual loading of the plugins.
   LoadPluginsInternal(&new_plugin_groups);
 
   base::AutoLock lock(lock_);
+  // Grab all plugins that were found before to copy enabled statuses.
+  std::vector<webkit::WebPluginInfo> old_plugins;
+  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
+    const std::vector<webkit::WebPluginInfo>& gr_plugins =
+        plugin_groups_[i]->web_plugins_info();
+    old_plugins.insert(old_plugins.end(), gr_plugins.begin(), gr_plugins.end());
+  }
+  // Disable all of the plugins and plugin groups that are disabled by policy.
+  for (size_t i = 0; i < new_plugin_groups.size(); ++i) {
+    PluginGroup* group = new_plugin_groups[i];
+    string16 group_name = group->GetGroupName();
+
+    std::vector<webkit::WebPluginInfo>& gr_plugins =
+        group->GetPluginsContainer();
+    for (size_t j = 0; j < gr_plugins.size(); ++j) {
+      int plugin_found = -1;
+      for (size_t k = 0; k < old_plugins.size(); ++k) {
+        if (gr_plugins[j].path == old_plugins[k].path) {
+          plugin_found = k;
+          break;
+        }
+      }
+      if (plugin_found >= 0)
+        gr_plugins[j].enabled = old_plugins[plugin_found].enabled;
+      // Set the disabled flag of all plugins scheduled for disabling.
+      if (plugins_to_disable_.find(gr_plugins[j].path) !=
+          plugins_to_disable_.end()) {
+          group->DisablePlugin(gr_plugins[j].path);
+      }
+    }
+
+    if (group->IsEmpty()) {
+      new_plugin_groups.erase(new_plugin_groups.begin() + i);
+      --i;
+      continue;
+    }
+
+    group->EnforceGroupPolicy();
+  }
+  // We flush the list of prematurely disabled plugins after the load has
+  // finished. If for some reason a plugin reappears on a second load it is
+  // going to be loaded normally. This is only true for non-policy controlled
+  // plugins though.
+  plugins_to_disable_.clear();
+
   plugin_groups_.swap(new_plugin_groups);
 }
 
 void PluginList::LoadPlugin(const FilePath& path,
                             ScopedVector<PluginGroup>* plugin_groups) {
   LOG_IF(ERROR, PluginList::DebugPluginLoading())
       << "Loading plugin " << path.value();
   WebPluginInfo plugin_info;
   const PluginEntryPoints* entry_points;
 
@@ skipping 20 matching lines @@
 
   base::AutoLock lock(lock_);
   AddToPluginGroups(plugin_info, plugin_groups);
 }
 
 void PluginList::GetPlugins(std::vector<WebPluginInfo>* plugins) {
   LoadPlugins();
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     const std::vector<webkit::WebPluginInfo>& gr_plugins =
-        plugin_groups_[i]->web_plugin_infos();
+        plugin_groups_[i]->web_plugins_info();
     plugins->insert(plugins->end(), gr_plugins.begin(), gr_plugins.end());
   }
 }
 
 void PluginList::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     bool* use_stale,
     std::vector<webkit::WebPluginInfo>* info,
     std::vector<std::string>* actual_mime_types) {
   DCHECK(mime_type == StringToLowerASCII(mime_type));
   DCHECK(info);
 
   if (!use_stale)
     LoadPlugins();
   base::AutoLock lock(lock_);
   if (use_stale)
     *use_stale = plugins_need_refresh_;
   info->clear();
   if (actual_mime_types)
     actual_mime_types->clear();
 
   std::set<FilePath> visited_plugins;
 
   // Add in plugins by mime type.
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     const std::vector<webkit::WebPluginInfo>& plugins =
-        plugin_groups_[i]->web_plugin_infos();
+        plugin_groups_[i]->web_plugins_info();
     for (size_t i = 0; i < plugins.size(); ++i) {
       if (SupportsType(plugins[i], mime_type, allow_wildcard)) {
         FilePath path = plugins[i].path;
         if (path.value() != kDefaultPluginLibraryName &&
             visited_plugins.insert(path).second) {
           info->push_back(plugins[i]);
           if (actual_mime_types)
             actual_mime_types->push_back(mime_type);
         }
       }
     }
   }
 
   // Add in plugins by url.
   std::string path = url.path();
   std::string::size_type last_dot = path.rfind('.');
   if (last_dot != std::string::npos) {
     std::string extension = StringToLowerASCII(std::string(path, last_dot+1));
     std::string actual_mime_type;
     for (size_t i = 0; i < plugin_groups_.size(); ++i) {
       const std::vector<webkit::WebPluginInfo>& plugins =
-          plugin_groups_[i]->web_plugin_infos();
+          plugin_groups_[i]->web_plugins_info();
       for (size_t i = 0; i < plugins.size(); ++i) {
         if (SupportsExtension(plugins[i], extension, &actual_mime_type)) {
           FilePath path = plugins[i].path;
           if (path.value() != kDefaultPluginLibraryName &&
               visited_plugins.insert(path).second) {
             info->push_back(plugins[i]);
             if (actual_mime_types)
               actual_mime_types->push_back(actual_mime_type);
           }
         }
       }
     }
   }
 
   // Add the default plugin at the end if it supports the mime type given,
   // and the default plugin is enabled.
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
 #if defined(OS_WIN)
     if (plugin_groups_[i]->identifier().compare(
         WideToUTF8(kDefaultPluginLibraryName)) == 0) {
 #else
     if (plugin_groups_[i]->identifier().compare(
         kDefaultPluginLibraryName) == 0) {
 #endif
-      DCHECK_NE(0U, plugin_groups_[i]->web_plugin_infos().size());
+      DCHECK_NE(0U, plugin_groups_[i]->web_plugins_info().size());
       const webkit::WebPluginInfo& default_info =
-          plugin_groups_[i]->web_plugin_infos()[0];
+          plugin_groups_[i]->web_plugins_info()[0];
       if (SupportsType(default_info, mime_type, allow_wildcard)) {
         info->push_back(default_info);
         if (actual_mime_types)
           actual_mime_types->push_back(mime_type);
       }
     }
   }
 }
 
 bool PluginList::GetPluginInfoByPath(const FilePath& plugin_path,
                                      webkit::WebPluginInfo* info) {
   LoadPlugins();
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     const std::vector<webkit::WebPluginInfo>& plugins =
-        plugin_groups_[i]->web_plugin_infos();
+        plugin_groups_[i]->web_plugins_info();
     for (size_t i = 0; i < plugins.size(); ++i) {
       if (plugins[i].path == plugin_path) {
         *info = plugins[i];
         return true;
       }
     }
   }
 
   return false;
 }
 
 void PluginList::GetPluginGroups(
     bool load_if_necessary,
     std::vector<PluginGroup>* plugin_groups) {
   if (load_if_necessary)
     LoadPlugins();
   base::AutoLock lock(lock_);
   plugin_groups->clear();
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     // In some unit tests we can get confronted with empty groups but in real
     // world code this if should never be false here.
     if (!plugin_groups_[i]->IsEmpty())
       plugin_groups->push_back(*plugin_groups_[i]);
   }
 }
 
-PluginGroup* PluginList::GetPluginGroup(
+const PluginGroup* PluginList::GetPluginGroup(
     const webkit::WebPluginInfo& web_plugin_info) {
   base::AutoLock lock(lock_);
-  return new PluginGroup(*AddToPluginGroups(web_plugin_info, &plugin_groups_));
+  return AddToPluginGroups(web_plugin_info, &plugin_groups_);
 }
 
 string16 PluginList::GetPluginGroupName(const std::string& identifier) {
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     if (plugin_groups_[i]->identifier() == identifier)
       return plugin_groups_[i]->GetGroupName();
   }
   return string16();
 }
 
@@ skipping 32 matching lines @@
     // is not going to run anyway.
     for (size_t i = 0; i < plugin_groups->size(); ++i) {
       if ((*plugin_groups)[i]->identifier() == identifier) {
         group->set_identifier(PluginGroup::GetLongIdentifier(web_plugin_info));
         break;
       }
     }
     plugin_groups->push_back(group);
   }
   group->AddPlugin(web_plugin_info);
+  // If group is scheduled for disabling do that now and remove it from the
+  // list.
+  if (groups_to_disable_.erase(group->GetGroupName()))
+    group->EnableGroup(false);
   return group;
 }
 
+bool PluginList::EnablePlugin(const FilePath& filename) {
+  base::AutoLock lock(lock_);
+  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
+    if (plugin_groups_[i]->ContainsPlugin(filename))
+      return plugin_groups_[i]->EnablePlugin(filename);
+  }
+  // Non existing plugin is being enabled. Check if it has been disabled before
+  // and remove it.
+  return (plugins_to_disable_.erase(filename) != 0);
+}
+
+bool PluginList::DisablePlugin(const FilePath& filename) {
+  base::AutoLock lock(lock_);
+  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
+    if (plugin_groups_[i]->ContainsPlugin(filename))
+      return plugin_groups_[i]->DisablePlugin(filename);
+  }
+  // Non existing plugin is being disabled. Queue the plugin so that on the next
+  // load plugins call they will be disabled.
+  plugins_to_disable_.insert(filename);
+  return true;
+}
+
+bool PluginList::EnableGroup(bool enable, const string16& group_name) {
+  base::AutoLock lock(lock_);
+  PluginGroup* group = NULL;
+  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
+    if (!plugin_groups_[i]->IsEmpty() &&
+        plugin_groups_[i]->GetGroupName().find(group_name) != string16::npos) {
+      group = plugin_groups_[i];
+      break;
+    }
+  }
+  if (!group) {
+    // Non existing group is being enabled. Queue the group so that on the next
+    // load plugins call they will be disabled.
+    if (!enable) {
+      groups_to_disable_.insert(group_name);
+      return true;
+    } else {
+      return (groups_to_disable_.erase(group_name) != 0);
+    }
+  }
+
+  return group->EnableGroup(enable);
+}
+
 bool PluginList::SupportsType(const webkit::WebPluginInfo& plugin,
                               const std::string& mime_type,
                               bool allow_wildcard) {
   // Webkit will ask for a plugin to handle empty mime types.
   if (mime_type.empty())
     return false;
 
   for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
     const webkit::WebPluginMimeType& mime_info = plugin.mime_types[i];
     if (net::MatchesMimeType(mime_info.mime_type, mime_type)) {
@@ skipping 20 matching lines @@
   }
   return false;
 }
 
 PluginList::~PluginList() {
 }
 
 
 }  // namespace npapi
 }  // namespace webkit