plugins: drop PluginVersionInfo for internal plugins

webkit/plugins/npapi/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/plugins/npapi/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 198 matching lines @@
 }
 
 void PluginList::AddExtraPluginDir(const FilePath& plugin_dir) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   AutoLock lock(lock_);
   extra_plugin_dirs_.push_back(plugin_dir);
 #endif
 }
 
-void PluginList::RegisterInternalPlugin(const PluginVersionInfo& info) {
+void PluginList::RegisterInternalPlugin(const WebPluginInfo& info) {
+  PluginEntryPoints entry_points = {0};
+  InternalPlugin plugin = { info, entry_points };
+
   AutoLock lock(lock_);
-  internal_plugins_.push_back(info);
-}
-
-void PluginList::RegisterInternalPlugin(const FilePath& path) {
-  webkit::npapi::PluginVersionInfo info;
-  info.path = path;
-  memset(&info.entry_points, 0, sizeof(info.entry_points));
-  RegisterInternalPlugin(info);
+  internal_plugins_.push_back(plugin);
 }
 
 void PluginList::RegisterInternalPlugin(const FilePath& filename,
                                         const std::string& name,
                                         const std::string& description,
-                                        const std::string& mime_type,
+                                        const std::string& mime_type_str,
                                         const PluginEntryPoints& entry_points) {
-  webkit::npapi::PluginVersionInfo info = {
-    filename,
-    ASCIIToWide(name),
-    ASCIIToWide(description),
-    L"1",
-    ASCIIToWide(mime_type),
-    L"",
-    L"",
-    entry_points
-  };
-  RegisterInternalPlugin(info);
+  InternalPlugin plugin;
+  plugin.info.path = filename;
+  plugin.info.name = ASCIIToUTF16(name);
+  plugin.info.version = ASCIIToUTF16("1");
+  plugin.info.desc = ASCIIToUTF16(description);

[pastarmovj, 2011/01/13 13:36:08]

You should be setting the enabled flag to true here as well or else it will be
in a random state.

+  WebPluginMimeType mime_type;
+  mime_type.mime_type = mime_type_str;
+  plugin.info.mime_types.push_back(mime_type);
+  plugin.entry_points = entry_points;
+
+  AutoLock lock(lock_);
+  internal_plugins_.push_back(plugin);
 }
 
 void PluginList::UnregisterInternalPlugin(const FilePath& path) {
   AutoLock lock(lock_);
   for (size_t i = 0; i < internal_plugins_.size(); i++) {
-    if (internal_plugins_[i].path == path) {
+    if (internal_plugins_[i].info.path == path) {
       internal_plugins_.erase(internal_plugins_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
 bool PluginList::ReadPluginInfo(const FilePath& filename,
                                 WebPluginInfo* info,
                                 const PluginEntryPoints** entry_points) {
   {
     AutoLock lock(lock_);
     for (size_t i = 0; i < internal_plugins_.size(); ++i) {
-      if (filename == internal_plugins_[i].path) {
+      if (filename == internal_plugins_[i].info.path) {
         *entry_points = &internal_plugins_[i].entry_points;
-        return CreateWebPluginInfo(internal_plugins_[i], info);
+        *info = internal_plugins_[i].info;
+        return true;
       }
     }
   }
 
   // Not an internal plugin.
   *entry_points = NULL;
 
   return PluginLib::ReadWebPluginInfo(filename, info);
 }
 
-bool PluginList::CreateWebPluginInfo(const PluginVersionInfo& pvi,
-                                     WebPluginInfo* 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<std::string> mime_types, file_extensions;
   std::vector<string16> descriptions;
-  base::SplitString(WideToUTF8(pvi.mime_types), '|', &mime_types);
-  base::SplitString(WideToUTF8(pvi.file_extensions), '|', &file_extensions);
-  base::SplitString(WideToUTF16(pvi.type_descriptions), '|', &descriptions);
+  base::SplitString(mime_types_str, '|', &mime_types);
+  base::SplitString(file_extensions_str, '|', &file_extensions);
+  base::SplitString(mime_type_descriptions_str, '|', &descriptions);
 
-  info->mime_types.clear();
+  parsed_mime_types->clear();
 
-  if (mime_types.empty()) {
-    LOG_IF(ERROR, PluginList::DebugPluginLoading())
-        << "Plugin " << pvi.product_name << " has no MIME types, skipping";
+  if (mime_types.empty())
     return false;
-  }
-
-  info->name = WideToUTF16(pvi.product_name);
-  info->desc = WideToUTF16(pvi.file_description);
-  info->version = WideToUTF16(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)
       base::SplitString(file_extensions[i], ',', &mime_type.file_extensions);
 
     if (descriptions.size() > i) {
       mime_type.description = descriptions[i];
 
       // On Windows, the description likely has a list of file extensions
       // embedded in it (e.g. "SurfWriter file (*.swr)"). Remove an extension
       // list from the description if it is present.
       size_t ext = mime_type.description.find(ASCIIToUTF16("(*"));
       if (ext != string16::npos) {
-        if (ext > 1 && mime_type.description[ext -1] == ' ')
+        if (ext > 1 && mime_type.description[ext - 1] == ' ')
           ext--;
 
         mime_type.description.erase(ext);
       }
     }
 
-    info->mime_types.push_back(mime_type);
+    parsed_mime_types->push_back(mime_type);
   }
 
   return true;
 }
 
 PluginList::PluginList()
     : plugins_loaded_(false),
       plugins_need_refresh_(false),
       disable_outdated_plugins_(false),
       next_priority_(0) {
   PlatformInit();
   AddHardcodedPluginGroups();
 }
 
 bool PluginList::ShouldDisableGroup(const string16& group_name) {
   AutoLock lock(lock_);
   if (PluginGroup::IsPluginNameDisabledByPolicy(group_name)) {
     disabled_groups_.insert(group_name);
     return true;
   }
   return disabled_groups_.count(group_name) > 0;
 }
 
 void PluginList::LoadPlugins(bool refresh) {
   // Don't want to hold the lock while loading new plugins, so we don't block
   // other methods if they're called on other threads.
   std::vector<FilePath> extra_plugin_paths;
   std::vector<FilePath> extra_plugin_dirs;
-  std::vector<PluginVersionInfo> internal_plugins;
+  std::vector<InternalPlugin> internal_plugins;
   {
     AutoLock lock(lock_);
     if (plugins_loaded_ && !refresh && !plugins_need_refresh_)
       return;
 
     // Clear the refresh bit now, because it might get set again before we
     // reach the end of the method.
     plugins_need_refresh_ = false;
     extra_plugin_paths = extra_plugin_paths_;
     extra_plugin_dirs = extra_plugin_dirs_;
     internal_plugins = internal_plugins_;
   }
 
   std::vector<WebPluginInfo> new_plugins;
   std::set<FilePath> visited_plugins;
 
   std::vector<FilePath> directories_to_scan;
   GetPluginDirectories(&directories_to_scan);
 
   // Load internal plugins first so that, if both an internal plugin and a
   // "discovered" plugin want to handle the same type, the internal plugin
   // will have precedence.
   for (size_t i = 0; i < internal_plugins.size(); ++i) {
-    if (internal_plugins[i].path.value() == kDefaultPluginLibraryName)
+    if (internal_plugins[i].info.path.value() == kDefaultPluginLibraryName)
       continue;
-    LoadPlugin(internal_plugins[i].path, &new_plugins);
+    LoadPlugin(internal_plugins[i].info.path, &new_plugins);
   }
 
   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);
     visited_plugins.insert(path);
   }
 
@@ skipping 423 matching lines @@
   Shutdown();
 }
 
 void PluginList::Shutdown() {
   STLDeleteContainerPairSecondPointers(plugin_groups_.begin(),
                                        plugin_groups_.end());
 }
 
 }  // namespace npapi
 }  // namespace webkit