[2] Adding a method to PluginFinder to get a PluginInstaller by WebPluginInfo.

chrome/browser/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/plugin_finder.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/plugin_installer.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "grit/browser_resources.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 
 using base::DictionaryValue;
 
+namespace {
+
+// 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
+}
+
+}  // namespace
+
 // static
 void PluginFinder::Get(const base::Callback<void(PluginFinder*)>& cb) {
   // At a later point we might want to do intialization here that needs to be
   // done asynchronously, like loading the plug-in list from disk or from a URL.
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(cb, GetInstance()));
 }
 
 // static
 PluginFinder* PluginFinder::GetInstance() {
   // PluginFinder::GetInstance() is the only method that's allowed to call
@@ skipping 88 matching lines @@
   DCHECK(!installers_[identifier]);
   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);
 
   PluginInstaller* installer = new PluginInstaller(identifier,
                                                    name,
                                                    display_url,
                                                    GURL(url),
-                                                   GURL(help_url));
+                                                   GURL(help_url),
+                                                   group_name_matcher);
   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);
       PluginInstaller::SecurityStatus status =
           PluginInstaller::SECURITY_STATUS_UP_TO_DATE;
       success = PluginInstaller::ParseSecurityStatus(status_str, &status);
       DCHECK(success);
       installer->AddVersion(Version(version), status);
     }
   }
 
   installers_[identifier] = installer;
   return installer;
 }
+
+PluginInstaller* PluginFinder::GetPluginInstaller(
+    const webkit::WebPluginInfo& plugin) {
+  if (name_installers_.find(plugin.name) != name_installers_.end())
+    return name_installers_[plugin.name];
+
+  for (DictionaryValue::Iterator plugin_it(*plugin_list_);
+      plugin_it.HasNext(); plugin_it.Advance()) {

[Bernhard Bauer, 2012/08/23 09:05:07]

Nit: I think aligning this line with `DictionaryValue...` looks a bit nicer.

[ibraaaa, 2012/08/23 09:58:33]

Done.

+    // This method triggers the lazy initialization for all PluginInstallers.
+    FindPluginWithIdentifier(plugin_it.key());
+  }
+
+  // Use the group name matcher to find the plug-in installer we want.
+  for (std::map<std::string, PluginInstaller*>::const_iterator it =
+      installers_.begin(); it != installers_.end(); ++it) {
+    if (!it->second->IsPluginMatchingGroupMatcher(plugin))
+      continue;
+
+    name_installers_[plugin.name] = it->second;
+    return it->second;
+  }
+
+  // The plug-in installer was not found, create a dummy one holding
+  // the name, identifier and group name only.
+  std::string identifier = GetIdentifier(plugin);
+  PluginInstaller* installer = new PluginInstaller(identifier,
+                                                   GetGroupName(plugin),
+                                                   false, GURL(), GURL(),
+                                                   string16());
+  installers_[identifier] = installer;
+  name_installers_[plugin.name] = installer;
+  return installer;
+}