Policy: Re-enabled plugin still disabled

webkit/glue/plugins/plugin_list.cc

Index: webkit/glue/plugins/plugin_list.cc
diff --git a/webkit/glue/plugins/plugin_list.cc b/webkit/glue/plugins/plugin_list.cc
index d682cce24bcdeb28e9b52b352b6a65ea1b0ebc61..60ec567c18d618f8633c02536f77907ac17abcb5 100644
--- a/webkit/glue/plugins/plugin_list.cc
+++ b/webkit/glue/plugins/plugin_list.cc
@@ -289,7 +289,7 @@ PluginList::PluginList()
 bool PluginList::ShouldDisableGroup(const string16& group_name) {
   AutoLock lock(lock_);
   if (PluginGroup::IsPluginNameDisabledByPolicy(group_name)) {
-    disabled_groups_.insert(group_name);
+    disabled_groups_.insert(DisabledGroupsListElement(group_name, POLICY));
     return true;
   }
   return disabled_groups_.count(group_name) > 0;
@@ -314,7 +314,6 @@ void PluginList::LoadPlugins(bool refresh) {
     internal_plugins = internal_plugins_;
   }
 
-  std::vector<WebPluginInfo> new_plugins;
   std::set<FilePath> visited_plugins;
 
   std::vector<FilePath> directories_to_scan;
@@ -326,23 +325,23 @@ void PluginList::LoadPlugins(bool refresh) {
   for (size_t i = 0; i < internal_plugins.size(); ++i) {
     if (internal_plugins[i].path.value() == kDefaultPluginLibraryName)
       continue;
-    LoadPlugin(internal_plugins[i].path, &new_plugins);
+    LoadPlugin(internal_plugins[i].path);
   }
 
   for (size_t i = 0; i < extra_plugin_paths.size(); ++i) {
     const FilePath& path = extra_plugin_paths[i];
     if (visited_plugins.find(path) != visited_plugins.end())
       continue;
-    LoadPlugin(path, &new_plugins);
+    LoadPlugin(path);
     visited_plugins.insert(path);
   }
 
   for (size_t i = 0; i < extra_plugin_dirs.size(); ++i) {
-    LoadPluginsFromDir(extra_plugin_dirs[i], &new_plugins, &visited_plugins);
+    LoadPluginsFromDir(extra_plugin_dirs[i], &visited_plugins);
   }
 
   for (size_t i = 0; i < directories_to_scan.size(); ++i) {
-    LoadPluginsFromDir(directories_to_scan[i], &new_plugins, &visited_plugins);
+    LoadPluginsFromDir(directories_to_scan[i], &visited_plugins);
   }
 
 #if defined(OS_WIN)
@@ -351,7 +350,7 @@ void PluginList::LoadPlugins(bool refresh) {
 
   // Load the default plugin last.
   if (webkit_glue::IsDefaultPluginEnabled())
-    LoadPlugin(FilePath(kDefaultPluginLibraryName), &new_plugins);
+    LoadPlugin(FilePath(kDefaultPluginLibraryName));
 
   // Disable all of the plugins and plugin groups that are disabled by policy.
   // There's currenly a bug that makes it impossible to correctly re-enable
@@ -371,19 +370,16 @@ void PluginList::LoadPlugins(bool refresh) {
     }
     if (!group->Enabled()) {
       AutoLock lock(lock_);
-      disabled_groups_.insert(group_name);
+      if (disabled_groups_.count(group_name) == 0)
+        disabled_groups_.insert(DisabledGroupsListElement(group_name, USER));
     }
   }
 
-  // Only update the data now since loading plugins can take a while.
   AutoLock lock(lock_);
-
-  plugins_ = new_plugins;
   plugins_loaded_ = true;
 }
 
-void PluginList::LoadPlugin(const FilePath& path,
-                            std::vector<WebPluginInfo>* plugins) {
+void PluginList::LoadPlugin(const FilePath& path) {
   LOG_IF(ERROR, PluginList::DebugPluginLoading())
       << "Loading plugin " << path.value();
 
@@ -393,7 +389,7 @@ void PluginList::LoadPlugin(const FilePath& path,
   if (!ReadPluginInfo(path, &plugin_info, &entry_points))
     return;
 
-  if (!ShouldLoadPlugin(plugin_info, plugins))
+  if (!ShouldLoadPlugin(plugin_info))
     return;
 
   if (path.value() != kDefaultPluginLibraryName
@@ -420,7 +416,6 @@ void PluginList::LoadPlugin(const FilePath& path,
   }
 
   AutoLock lock(lock_);
-  plugins->push_back(plugin_info);
   AddToPluginGroups(plugin_info);
 }
 
@@ -465,7 +460,11 @@ void PluginList::GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins) {
   LoadPlugins(refresh);
 
   AutoLock lock(lock_);
-  *plugins = plugins_;
+  for (std::vector<WebPluginInfo*>::const_iterator it = plugins_.begin();
+       it != plugins_.end();
+       ++it) {
+    plugins->push_back(**it);
+  }
 }
 
 void PluginList::GetEnabledPlugins(bool refresh,
@@ -474,11 +473,11 @@ void PluginList::GetEnabledPlugins(bool refresh,
 
   plugins->clear();
   AutoLock lock(lock_);
-  for (std::vector<WebPluginInfo>::const_iterator it = plugins_.begin();
+  for (std::vector<WebPluginInfo*>::const_iterator it = plugins_.begin();
        it != plugins_.end();
        ++it) {
-    if (it->enabled)
-      plugins->push_back(*it);
+    if ((*it)->enabled)
+      plugins->push_back(**it);
   }
 }
 
@@ -502,12 +501,12 @@ void PluginList::GetPluginInfoArray(
   // Add in enabled plugins by mime type.
   WebPluginInfo default_plugin;
   for (size_t i = 0; i < plugins_.size(); ++i) {
-    if (plugins_[i].enabled &&
-        SupportsType(plugins_[i], mime_type, allow_wildcard)) {
-      FilePath path = plugins_[i].path;
+    if (plugins_[i]->enabled &&
+        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]);
+        info->push_back(*plugins_[i]);
         if (actual_mime_types)
           actual_mime_types->push_back(mime_type);
       }
@@ -521,12 +520,12 @@ void PluginList::GetPluginInfoArray(
     std::string extension = StringToLowerASCII(std::string(path, last_dot+1));
     std::string actual_mime_type;
     for (size_t i = 0; i < plugins_.size(); ++i) {
-      if (plugins_[i].enabled &&
-          SupportsExtension(plugins_[i], extension, &actual_mime_type)) {
-        FilePath path = plugins_[i].path;
+      if (plugins_[i]->enabled &&
+          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]);
+          info->push_back(*plugins_[i]);
           if (actual_mime_types)
             actual_mime_types->push_back(actual_mime_type);
         }
@@ -536,12 +535,12 @@ void PluginList::GetPluginInfoArray(
 
   // Add in disabled plugins by mime type.
   for (size_t i = 0; i < plugins_.size(); ++i) {
-    if (!plugins_[i].enabled &&
-        SupportsType(plugins_[i], mime_type, allow_wildcard)) {
-      FilePath path = plugins_[i].path;
+    if (!plugins_[i]->enabled &&
+        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]);
+        info->push_back(*plugins_[i]);
         if (actual_mime_types)
           actual_mime_types->push_back(mime_type);
       }
@@ -551,7 +550,7 @@ void PluginList::GetPluginInfoArray(
   // Add the default plugin at the end if it supports the mime type given,
   // and the default plugin is enabled.
   if (!plugins_.empty() && webkit_glue::IsDefaultPluginEnabled()) {
-    const WebPluginInfo& default_info = plugins_.back();
+    const WebPluginInfo& default_info = *plugins_.back();
     if (SupportsType(default_info, mime_type, allow_wildcard)) {
       info->push_back(default_info);
       if (actual_mime_types)
@@ -594,8 +593,8 @@ bool PluginList::GetPluginInfoByPath(const FilePath& plugin_path,
   LoadPlugins(false);
   AutoLock lock(lock_);
   for (size_t i = 0; i < plugins_.size(); ++i) {
-    if (plugins_[i].path == plugin_path) {
-      *info = plugins_[i];
+    if (plugins_[i]->path == plugin_path) {
+      *info = *plugins_[i];
       return true;
     }
   }
@@ -670,7 +669,22 @@ PluginGroup* PluginList::AddToPluginGroups(
     DCHECK(plugin_groups_.find(identifier) == plugin_groups_.end());
     plugin_groups_.insert(std::make_pair(identifier, group));
   }
-  group->AddPlugin(web_plugin_info, next_priority_++);
+  WebPluginInfo* group_copy = group->AddPlugin(web_plugin_info, next_priority_);
+  if (group_copy) {
+    next_priority_++;
+    plugins_.push_back(group_copy);
+    string16 group_name = group->GetGroupName();
+    if (!group->Enabled() && !disabled_groups_.count(group_name)) {
+      disabled_groups_.insert(DisabledGroupsListElement(
+          group_name,
+          PluginGroup::IsPluginNameDisabledByPolicy(group_name) ?
+              POLICY : USER));
+    } else if (group->Enabled() && disabled_groups_.count(group_name)) {
+      disabled_groups_.erase(group_name);
+    }
+    // We don't need to protect the flag here because it is protected from the
+    // callers of |AddToPluginGroups|.

[Bernhard Bauer, 2010/12/15 17:23:45]

Nit: Leftover comment?

+  }
   return group;
 }
 
@@ -679,19 +693,29 @@ bool PluginList::EnablePlugin(const FilePath& filename) {
 
   bool did_enable = false;
 
-  std::set<FilePath>::iterator entry = disabled_plugins_.find(filename);
-  if (entry == disabled_plugins_.end())
+  DisabledPlugins::iterator entry =
+      disabled_plugins_.find(filename);
+  if (entry == disabled_plugins_.end() || entry->second == POLICY)
     return did_enable;  // Early exit if plugin not in disabled list.

[Bernhard Bauer, 2010/12/15 17:23:45]

Please update this comment.

 
   disabled_plugins_.erase(entry);  // Remove from disabled list.
 
   // Set enabled flags if necessary.
-  for (std::vector<WebPluginInfo>::iterator it = plugins_.begin();
+  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;
+    if ((*it)->path == filename) {
+      DCHECK(!(*it)->enabled);  // Should have been disabled.
+      (*it)->enabled = true;
+      PluginGroup* group = AddToPluginGroups(**it);
+      bool group_was_enabled = group->Enabled();
+      group->RefreshEnabledState();
+      if (group_was_enabled && group->Enabled()) {
+        DisabledGroups::iterator entry =
+            disabled_groups_.find(group->GetGroupName());
+        if (entry != disabled_groups_.end())
+          disabled_groups_.erase(entry);

[Bernhard Bauer, 2010/12/15 17:23:45]

Nit: just disabled_groups_.erase(group->GetGroupName());

+      }
       did_enable = true;
     }
   }
@@ -699,23 +723,40 @@ bool PluginList::EnablePlugin(const FilePath& filename) {
   return did_enable;
 }
 
-bool PluginList::DisablePlugin(const FilePath& filename) {
+bool PluginList::DisablePlugin(const FilePath& filename, bool policy_disabled) {
   AutoLock lock(lock_);
 
   bool did_disable = false;
 
-  if (disabled_plugins_.find(filename) != disabled_plugins_.end())
+  DisabledPlugins::iterator entry =
+      disabled_plugins_.find(filename);
+  if (entry != disabled_plugins_.end()) {
+    if ((entry->second == POLICY && !policy_disabled) ||
+        (entry->second == USER && policy_disabled))
+      entry->second = POLICY_AND_USER;

[Bernhard Bauer, 2010/12/15 17:23:45]

Nit: Braces around this line.

     return did_disable;  // Early exit if plugin already in disabled list.

[Bernhard Bauer, 2010/12/15 17:23:45]

Nit: Update comment.

+  }
 
-  disabled_plugins_.insert(filename);  // Add to disabled list.
+  // Add to disabled list.
+  disabled_plugins_.insert(
+      DisabledPluginsListElement(filename, policy_disabled ? POLICY : USER));
 
   // Unset enabled flags if necessary.
-  for (std::vector<WebPluginInfo>::iterator it = plugins_.begin();
+  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;
+    if ((*it)->path == filename) {
+      DCHECK((*it)->enabled);  // Should have been enabled.
+      (*it)->enabled = false;
+      PluginGroup* group = AddToPluginGroups(**it);
+      group->RefreshEnabledState();
+      if (!group->Enabled()) {
+        if (!disabled_groups_.count(group->GetGroupName())) {
+          disabled_groups_.insert(
+              DisabledGroupsListElement(group->GetGroupName(),
+                                        policy_disabled ? POLICY : USER));
+        }
+      }
       did_disable = true;
     }
   }
@@ -728,15 +769,20 @@ bool PluginList::EnableGroup(bool enable, const string16& group_name) {
   {
     AutoLock lock(lock_);
 
-    std::set<string16>::iterator entry = disabled_groups_.find(group_name);
+    DisabledGroups::iterator entry =
+        disabled_groups_.find(group_name);
     if (enable) {
-      if (entry == disabled_groups_.end())
+      if (entry == disabled_groups_.end() || entry->second == POLICY)
         return did_change;  // Early exit if group not in disabled list.
       disabled_groups_.erase(entry);  // Remove from disabled list.
     } else {
       if (entry != disabled_groups_.end())
         return did_change;  // Early exit if group already in disabled list.
-      disabled_groups_.insert(group_name);
+      disabled_groups_.insert(
+          DisabledGroupsListElement(
+              group_name,
+              PluginGroup::IsPluginNameDisabledByPolicy(group_name) ?
+                  POLICY : USER));
     }
   }
 
@@ -758,6 +804,16 @@ void PluginList::DisableOutdatedPluginGroups() {
   disable_outdated_plugins_ = true;
 }
 
+const PluginList::DisabledPlugins&  PluginList::GetDisabledPlugins() const {
+  AutoLock lock(lock_);
+  return disabled_plugins_;
+}
+
+const PluginList::DisabledGroups& PluginList::GetDisabledGroups() const {
+  AutoLock lock(lock_);
+  return disabled_groups_;
+}
+
 PluginList::~PluginList() {
   Shutdown();
 }