Make WebPluginInfo more generic

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 192 matching lines @@
 }
 
 void PluginList::AddExtraPluginDir(const FilePath& plugin_dir) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_dirs_.push_back(plugin_dir);
 #endif
 }
 
-void PluginList::RegisterInternalPlugin(const WebPluginInfo& info) {
+void PluginList::RegisterInternalPlugin(const webkit::WebPluginInfo& info) {
   PluginEntryPoints entry_points = {0};
   InternalPlugin plugin = { info, entry_points };
 
   base::AutoLock lock(lock_);
   // Newer registrations go earlier in the list so they can override the MIME
   // types of older registrations.
   internal_plugins_.insert(internal_plugins_.begin(), plugin);
 }
 
 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 = WebPluginInfo::USER_ENABLED_POLICY_UNMANAGED;
+  plugin.info.enabled = webkit::WebPluginInfo::USER_ENABLED_POLICY_UNMANAGED;
 
-  WebPluginMimeType mime_type;
+  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)
     default_plugin_enabled_ = true;
 }
 
 void PluginList::UnregisterInternalPlugin(const FilePath& path) {
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < internal_plugins_.size(); i++) {
     if (internal_plugins_[i].info.path == path) {
       internal_plugins_.erase(internal_plugins_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
 bool PluginList::ReadPluginInfo(const FilePath& filename,
-                                WebPluginInfo* info,
+                                webkit::WebPluginInfo* info,
                                 const PluginEntryPoints** entry_points) {
   {
     base::AutoLock lock(lock_);
     for (size_t i = 0; i < internal_plugins_.size(); ++i) {
       if (filename == internal_plugins_[i].info.path) {
         *entry_points = &internal_plugins_[i].entry_points;
         *info = internal_plugins_[i].info;
         return true;
       }
     }
   }
 
   // Not an internal plugin.
   *entry_points = NULL;
 
   return PluginLib::ReadWebPluginInfo(filename, info);
 }
 
 // static
 bool PluginList::ParseMimeTypes(
     const std::string& mime_types_str,
     const std::string& file_extensions_str,
     const string16& mime_type_descriptions_str,
-    std::vector<WebPluginMimeType>* parsed_mime_types) {
+    std::vector<webkit::WebPluginMimeType>* parsed_mime_types) {
   std::vector<std::string> mime_types, file_extensions;
   std::vector<string16> descriptions;
   base::SplitString(mime_types_str, '|', &mime_types);
   base::SplitString(file_extensions_str, '|', &file_extensions);
   base::SplitString(mime_type_descriptions_str, '|', &descriptions);
 
   parsed_mime_types->clear();
 
   if (mime_types.empty())
     return false;
@@ skipping 110 matching lines @@
       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<WebPluginInfo> old_plugins;
+  std::vector<webkit::WebPluginInfo> old_plugins;
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<WebPluginInfo>& gr_plugins =
+    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<WebPluginInfo>& gr_plugins = group->GetPluginsContainer();
+    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;
@@ skipping 52 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<WebPluginInfo>& gr_plugins =
+    const std::vector<webkit::WebPluginInfo>& gr_plugins =
         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<WebPluginInfo>* info,
+    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 enabled plugins by mime type.
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<WebPluginInfo>& plugins =
+    const std::vector<webkit::WebPluginInfo>& plugins =
         plugin_groups_[i]->web_plugins_info();
     for (size_t i = 0; i < plugins.size(); ++i) {
       if (IsPluginEnabled(plugins[i]) && 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 enabled 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<WebPluginInfo>& plugins =
+      const std::vector<webkit::WebPluginInfo>& plugins =
           plugin_groups_[i]->web_plugins_info();
       for (size_t i = 0; i < plugins.size(); ++i) {
         if (IsPluginEnabled(plugins[i]) &&
             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 in disabled plugins by mime type.
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<WebPluginInfo>& plugins =
+    const std::vector<webkit::WebPluginInfo>& plugins =
         plugin_groups_[i]->web_plugins_info();
     for (size_t i = 0; i < plugins.size(); ++i) {
       if (!IsPluginEnabled(plugins[i]) &&
           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 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_plugins_info().size());
-      const WebPluginInfo& default_info =
+      const webkit::WebPluginInfo& default_info =
           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,
-                                     WebPluginInfo* info) {
+                                     webkit::WebPluginInfo* info) {
   LoadPlugins();
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<WebPluginInfo>& plugins =
+    const std::vector<webkit::WebPluginInfo>& plugins =
         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]);
   }
 }
 
 const PluginGroup* PluginList::GetPluginGroup(
-    const WebPluginInfo& web_plugin_info) {
+    const webkit::WebPluginInfo& web_plugin_info) {
   base::AutoLock lock(lock_);
   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();
 }
 
 std::string PluginList::GetPluginGroupIdentifier(
-    const WebPluginInfo& web_plugin_info) {
+    const webkit::WebPluginInfo& web_plugin_info) {
   base::AutoLock lock(lock_);
   PluginGroup* group = AddToPluginGroups(web_plugin_info, &plugin_groups_);
   return group->identifier();
 }
 
 void PluginList::AddHardcodedPluginGroups(ScopedVector<PluginGroup>* groups) {
   for (size_t i = 0; i < num_group_definitions_; ++i) {
     groups->push_back(
         PluginGroup::FromPluginGroupDefinition(group_definitions_[i]));
   }
 }
 
 PluginGroup* PluginList::AddToPluginGroups(
-    const WebPluginInfo& web_plugin_info,
+    const webkit::WebPluginInfo& web_plugin_info,
     ScopedVector<PluginGroup>* plugin_groups) {
   PluginGroup* group = NULL;
   for (size_t i = 0; i < plugin_groups->size(); ++i) {
     if ((*plugin_groups)[i]->Match(web_plugin_info)) {
       group = (*plugin_groups)[i];
       break;
     }
   }
   if (!group) {
     group = PluginGroup::FromWebPluginInfo(web_plugin_info);
@@ skipping 60 matching lines @@
       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 WebPluginInfo& plugin,
+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 WebPluginMimeType& mime_info = plugin.mime_types[i];
+    const webkit::WebPluginMimeType& mime_info = plugin.mime_types[i];
     if (net::MatchesMimeType(mime_info.mime_type, mime_type)) {
       if (!allow_wildcard && mime_info.mime_type == "*")
         continue;
       return true;
     }
   }
   return false;
 }
 
-bool PluginList::SupportsExtension(const WebPluginInfo& plugin,
+bool PluginList::SupportsExtension(const webkit::WebPluginInfo& plugin,
                                    const std::string& extension,
                                    std::string* actual_mime_type) {
   for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
-    const WebPluginMimeType& mime_type = plugin.mime_types[i];
+    const webkit::WebPluginMimeType& mime_type = plugin.mime_types[i];
     for (size_t j = 0; j < mime_type.file_extensions.size(); ++j) {
       if (mime_type.file_extensions[j] == extension) {
         if (actual_mime_type)
           *actual_mime_type = mime_type.mime_type;
         return true;
       }
     }
   }
   return false;
 }
 
 void PluginList::DisableOutdatedPluginGroups() {
   disable_outdated_plugins_ = true;
 }
 
 PluginList::~PluginList() {
 }
 
 
 }  // namespace npapi
 }  // namespace webkit