Using MIME types in addition to plugin name to differentiate between plugins.

chrome/browser/plugins/plugin_finder.cc

 // Copyright (c) 2012 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 "chrome/browser/plugins/plugin_finder.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 13 matching lines @@
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
 #include "chrome/browser/plugins/plugin_installer.h"
 #endif
 
 using base::DictionaryValue;
 using content::PluginService;
 
 namespace {
 
+typedef std::map<std::string, PluginMetadata*> PluginMap;
+
+const char kMimeTypesListKey[] = "mime_types";
+const char kMatchingMimeTypesListKey[] = "matching_mime_types";
+
 // Gets the base name of the file path as the identifier.
 static std::string GetIdentifier(const webkit::WebPluginInfo& plugin) {
 #if defined(OS_POSIX)
   return plugin.path.BaseName().value();
 #elif defined(OS_WIN)
   return base::SysWideToUTF8(plugin.path.BaseName().value());
 #endif
 }
 
 // Gets the plug-in group name as the plug-in name if it is not empty or
 // the filename without extension if the name is empty.
 static string16 GetGroupName(const webkit::WebPluginInfo& plugin) {
   if (!plugin.name.empty())
     return plugin.name;
 
   FilePath::StringType path = plugin.path.BaseName().RemoveExtension().value();
 #if defined(OS_POSIX)
   return UTF8ToUTF16(path);
 #elif defined(OS_WIN)
   return WideToUTF16(path);
 #endif
 }
 
+void LoadMimeTypes(const std::string& mime_type_list_key,

[Bernhard Bauer, 2012/10/04 12:31:16]

You don't really need to explicitly pass in the key here, do you? You could get
the correct key from the |matching_mime_types| flag.

[ibraaaa, 2012/10/04 13:03:42]

Well, that is what I thought but your last reply to my comment implied something
else (or I didn't understand it). Done.

Removed the constants for consistency, there are no constants for other keys.

On 2012/10/04 12:31:16, Bernhard Bauer wrote:

+                   bool matching_mime_types,
+                   const DictionaryValue* plugin_dict,
+                   PluginMetadata* plugin) {
+  const ListValue* mime_types = NULL;
+  if (!plugin_dict->GetList(mime_type_list_key, &mime_types))
+    return;
+
+  bool success = false;
+  for (ListValue::const_iterator mime_type_it = mime_types->begin();
+       mime_type_it != mime_types->end(); ++mime_type_it) {
+    std::string mime_type_str;
+    success = (*mime_type_it)->GetAsString(&mime_type_str);
+    DCHECK(success);
+    if (matching_mime_types) {
+      plugin->AddMatchingMimeType(mime_type_str);
+    } else {
+      plugin->AddMimeType(mime_type_str);
+    }
+  }
+}
+
 PluginMetadata* CreatePluginMetadata(
     const std::string& identifier,
     const DictionaryValue* plugin_dict) {
   std::string url;
   bool success = plugin_dict->GetString("url", &url);
   std::string help_url;
   plugin_dict->GetString("help_url", &help_url);
   string16 name;
   success = plugin_dict->GetString("name", &name);
   DCHECK(success);
   bool display_url = false;
   plugin_dict->GetBoolean("displayurl", &display_url);
   string16 group_name_matcher;
   success = plugin_dict->GetString("group_name_matcher", &group_name_matcher);
   DCHECK(success);
+  std::string language_str;
+  plugin_dict->GetString("lang", &language_str);
 
   PluginMetadata* plugin = new PluginMetadata(identifier,
                                               name,
                                               display_url,
                                               GURL(url),
                                               GURL(help_url),
-                                              group_name_matcher);
+                                              group_name_matcher,
+                                              language_str);
   const ListValue* versions = NULL;
   if (plugin_dict->GetList("versions", &versions)) {
     for (ListValue::const_iterator it = versions->begin();
          it != versions->end(); ++it) {
       DictionaryValue* version_dict = NULL;
       if (!(*it)->GetAsDictionary(&version_dict)) {
         NOTREACHED();
         continue;
       }
       std::string version;
       success = version_dict->GetString("version", &version);
       DCHECK(success);
       std::string status_str;
       success = version_dict->GetString("status", &status_str);
       DCHECK(success);
       PluginMetadata::SecurityStatus status =
           PluginMetadata::SECURITY_STATUS_UP_TO_DATE;
       success = PluginMetadata::ParseSecurityStatus(status_str, &status);
       DCHECK(success);
       plugin->AddVersion(Version(version), status);
     }
   }
 
+  LoadMimeTypes(kMimeTypesListKey, false, plugin_dict, plugin);
+  LoadMimeTypes(kMatchingMimeTypesListKey, true, plugin_dict, plugin);
   return plugin;
 }
 
 }  // namespace
 
 // static
 PluginFinder* PluginFinder::GetInstance() {
   // PluginFinder::GetInstance() is the only method that's allowed to call
   // Singleton<PluginFinder>::get().
   return Singleton<PluginFinder>::get();
@@ skipping 50 matching lines @@
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
 bool PluginFinder::FindPlugin(
     const std::string& mime_type,
     const std::string& language,
     PluginInstaller** installer,
     scoped_ptr<PluginMetadata>* plugin_metadata) {
   base::AutoLock lock(mutex_);
   if (g_browser_process->local_state()->GetBoolean(prefs::kDisablePluginFinder))
     return false;
-  for (DictionaryValue::Iterator plugin_it(*plugin_list_);
-       plugin_it.HasNext(); plugin_it.Advance()) {
-    const DictionaryValue* plugin = NULL;
-    if (!plugin_it.value().GetAsDictionary(&plugin)) {
-      NOTREACHED();
-      continue;
-    }
-    std::string language_str;
-    bool success = plugin->GetString("lang", &language_str);
-    if (language_str != language)
-      continue;
-    const ListValue* mime_types = NULL;
-    if (plugin->GetList("mime_types", &mime_types)) {
-      for (ListValue::const_iterator mime_type_it = mime_types->begin();
-           mime_type_it != mime_types->end(); ++mime_type_it) {
-        std::string mime_type_str;
-        success = (*mime_type_it)->GetAsString(&mime_type_str);
-        DCHECK(success);
-        if (mime_type_str == mime_type) {
-          std::string identifier = plugin_it.key();
-          std::map<std::string, PluginMetadata*>::const_iterator metadata_it =
-              identifier_plugin_.find(identifier);
-          DCHECK(metadata_it != identifier_plugin_.end());
-          *plugin_metadata = metadata_it->second->Clone();
 
-          std::map<std::string, PluginInstaller*>::const_iterator installer_it =
-              installers_.find(identifier);
-          DCHECK(installer_it != installers_.end());
-          *installer = installer_it->second;
-          return true;
-        }
-      }
+  PluginMap::const_iterator metadata_it = identifier_plugin_.begin();
+  for (; metadata_it != identifier_plugin_.end(); ++metadata_it) {
+    if (language == metadata_it->second->language() &&
+        metadata_it->second->HasMimeType(mime_type)) {
+      *plugin_metadata = metadata_it->second->Clone();
+
+      std::map<std::string, PluginInstaller*>::const_iterator installer_it =
+          installers_.find(metadata_it->second->identifier());
+      DCHECK(installer_it != installers_.end());
+      *installer = installer_it->second;
+      return true;
     }
   }
   return false;
 }
 
 bool PluginFinder::FindPluginWithIdentifier(
     const std::string& identifier,
     PluginInstaller** installer,
     scoped_ptr<PluginMetadata>* plugin_metadata) {
   base::AutoLock lock(mutex_);
   std::map<std::string, PluginInstaller*>::const_iterator it =
       installers_.find(identifier);
   if (it != installers_.end()) {
     *installer = it->second;
-    std::map<std::string, PluginMetadata*>::const_iterator metadata_it =
-        identifier_plugin_.find(identifier);
+    PluginMap::const_iterator metadata_it = identifier_plugin_.find(identifier);
     DCHECK(metadata_it != identifier_plugin_.end());
     *plugin_metadata = metadata_it->second->Clone();
     return true;
   }
 
   return false;
 }
 
 void PluginFinder::ReinitializePlugins(
     const base::DictionaryValue& json_metadata) {
   base::AutoLock lock(mutex_);
   STLDeleteValues(&identifier_plugin_);
   identifier_plugin_.clear();
-  name_plugin_.clear();
 
   plugin_list_.reset(json_metadata.DeepCopy());
   InitInternal();
 }
 #endif
 
 string16 PluginFinder::FindPluginNameWithIdentifier(
     const std::string& identifier) {
   base::AutoLock lock(mutex_);
-  std::map<std::string, PluginMetadata*>::const_iterator it =
-      identifier_plugin_.find(identifier);
+  PluginMap::const_iterator it = identifier_plugin_.find(identifier);
   string16 name;
   if (it != identifier_plugin_.end())
     name = it->second->name();
 
   return name.empty() ? UTF8ToUTF16(identifier) : name;
 }
 
 scoped_ptr<PluginMetadata> PluginFinder::GetPluginMetadata(
     const webkit::WebPluginInfo& plugin) {
   base::AutoLock lock(mutex_);
-  if (name_plugin_.find(plugin.name) != name_plugin_.end())
-    return name_plugin_[plugin.name]->Clone();
-
-  // Use the group name matcher to find the plug-in metadata we want.
-  for (std::map<std::string, PluginMetadata*>::const_iterator it =
-      identifier_plugin_.begin(); it != identifier_plugin_.end(); ++it) {
+  for (PluginMap::const_iterator it = identifier_plugin_.begin();
+       it != identifier_plugin_.end(); ++it) {
     if (!it->second->MatchesPlugin(plugin))
       continue;
 
-    name_plugin_[plugin.name] = it->second;
     return it->second->Clone();
   }
 
   // The plug-in metadata was not found, create a dummy one holding
   // the name, identifier and group name only.
   std::string identifier = GetIdentifier(plugin);
   PluginMetadata* metadata = new PluginMetadata(identifier,
                                                 GetGroupName(plugin),
                                                 false, GURL(), GURL(),
-                                                GetGroupName(plugin));
-
-  name_plugin_[plugin.name] = metadata;
+                                                GetGroupName(plugin),
+                                                "");
   identifier_plugin_[identifier] = metadata;
   return metadata->Clone();
 }
 
 void PluginFinder::InitInternal() {
   for (DictionaryValue::Iterator plugin_it(*plugin_list_);
       plugin_it.HasNext(); plugin_it.Advance()) {
     DictionaryValue* plugin = NULL;
     const std::string& identifier = plugin_it.key();
     if (plugin_list_->GetDictionaryWithoutPathExpansion(identifier, &plugin)) {
       DCHECK(!identifier_plugin_[identifier]);
       identifier_plugin_[identifier] = CreatePluginMetadata(identifier, plugin);
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
       if (installers_.find(identifier) == installers_.end())
         installers_[identifier] = new PluginInstaller();
 #endif
     }
   }
 }