PluginList: Unit tests and bugfixes

webkit/glue/plugins/plugin_list.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 "webkit/glue/plugins/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 455 matching lines @@
   for (std::vector<WebPluginInfo*>::const_iterator it = plugins_.begin();
        it != plugins_.end();
        ++it) {
     plugins->push_back(**it);
   }
 }
 
 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);
   }
 }
 
@@ skipping 120 matching lines @@
 
 void PluginList::GetPluginGroups(
     bool load_if_necessary,
     std::vector<PluginGroup>* plugin_groups) {
   if (load_if_necessary)
     LoadPlugins(false);
   AutoLock lock(lock_);
   plugin_groups->clear();
   for (PluginGroup::PluginMap::const_iterator it = plugin_groups_.begin();
        it != plugin_groups_.end(); ++it) {
-    plugin_groups->push_back(*it->second);
+    if (!it->second->IsEmpty())
+      plugin_groups->push_back(*it->second);
   }
 }
 
 const PluginGroup* PluginList::GetPluginGroup(
     const WebPluginInfo& web_plugin_info) {
   AutoLock lock(lock_);
-  return AddToPluginGroups(web_plugin_info, NULL);
+  return AddToPluginGroups(web_plugin_info, &plugins_);
 }
 
 string16 PluginList::GetPluginGroupName(std::string identifier) {
   PluginGroup::PluginMap::iterator it = plugin_groups_.find(identifier);
   if (it == plugin_groups_.end()) {
     return string16();
   }
   return it->second->GetGroupName();
 }
 
 std::string PluginList::GetPluginGroupIdentifier(
     const WebPluginInfo& web_plugin_info) {
   AutoLock lock(lock_);
-  PluginGroup* group = AddToPluginGroups(web_plugin_info, NULL);
+  PluginGroup* group = AddToPluginGroups(web_plugin_info, &plugins_);
   return group->identifier();
 }
 
 void PluginList::AddHardcodedPluginGroups() {
   AutoLock lock(lock_);
   const PluginGroupDefinition* definitions = GetPluginGroupDefinitions();
   for (size_t i = 0; i < GetPluginGroupDefinitionsSize(); ++i) {
     PluginGroup* definition_group = PluginGroup::FromPluginGroupDefinition(
         definitions[i]);
+    ProcessGroupAfterInitialize(definition_group);
     std::string identifier = definition_group->identifier();
     DCHECK(plugin_groups_.find(identifier) == plugin_groups_.end());
     plugin_groups_.insert(std::make_pair(identifier, definition_group));
   }
 }
 
 PluginGroup* PluginList::AddToPluginGroups(
     const WebPluginInfo& web_plugin_info,
     std::vector<WebPluginInfo*>* plugins) {
   PluginGroup* group = NULL;
   for (PluginGroup::PluginMap::iterator it = plugin_groups_.begin();
        it != plugin_groups_.end(); ++it) {
     if (it->second->Match(web_plugin_info))
       group = it->second;
   }
   if (!group) {
     group = PluginGroup::FromWebPluginInfo(web_plugin_info);
+    ProcessGroupAfterInitialize(group);
     std::string identifier = group->identifier();
     // If the identifier is not unique, use the full path. This means that we
     // probably won't be able to search for this group by identifier, but at
     // least it's going to be in the set of plugin groups, and if there
     // is already a plug-in with the same filename, it's probably going to
     // handle the same MIME types (and it has a higher priority), so this one
     // is not going to run anyway.
     if (plugin_groups_.find(identifier) != plugin_groups_.end())
       identifier = PluginGroup::GetLongIdentifier(web_plugin_info);
     DCHECK(plugin_groups_.find(identifier) == plugin_groups_.end());
     plugin_groups_.insert(std::make_pair(identifier, group));
   }
-  WebPluginInfo* group_plugin_copy;
-  bool is_new_addition = group->AddPlugin(
-      web_plugin_info, next_priority_, &group_plugin_copy);
-  if (plugins)
-    plugins->push_back(group_plugin_copy);
-  if (is_new_addition) {
-    next_priority_++;
-    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);
+  if (plugins) {
+    WebPluginInfo* group_plugin_copy;
+    bool is_new_addition = group->AddPlugin(
+        web_plugin_info, next_priority_, &group_plugin_copy);
+    if (is_new_addition) {
+      plugins->push_back(group_plugin_copy);
+      next_priority_++;
+      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|.
   }
   return group;
 }
 
 bool PluginList::EnablePlugin(const FilePath& filename) {
   AutoLock lock(lock_);
 
@@ skipping 133 matching lines @@
   // memory tree green.
 #if defined(OS_POSIX)
   if (RUNNING_ON_VALGRIND) {
     STLDeleteContainerPairSecondPointers(plugin_groups_.begin(),
                                          plugin_groups_.end());
   }
 #endif
 }
 
 }  // namespace NPAPI