Separate plugin_metadata from plugin_installer, thread-safe plugin_finder

chrome/browser/ui/webui/plugins_ui.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/ui/webui/plugins_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/api/prefs/pref_member.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/plugins/plugin_finder.h"
-#include "chrome/browser/plugins/plugin_installer.h"
+#include "chrome/browser/plugins/plugin_metadata.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 122 matching lines @@
 
   // Callback for the "setPluginAlwaysAllowed" message.
   void HandleSetPluginAlwaysAllowed(const ListValue* args);
 
   // content::NotificationObserver method overrides
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
-  // Call this to start getting the plugins on the UI thread.
-  void GetPluginFinder();
-
-  // Called when we have a PluginFinder and need to load the list of plug-ins.
-  void LoadPlugins(PluginFinder* plugin_finder);
+  void LoadPlugins();
 
   // Called on the UI thread when the plugin information is ready.
-  void PluginsLoaded(PluginFinder* plugin_finder,
-                     const std::vector<webkit::WebPluginInfo>& plugins);
+  void PluginsLoaded(const std::vector<webkit::WebPluginInfo>& plugins);
 
   content::NotificationRegistrar registrar_;
 
   base::WeakPtrFactory<PluginsDOMHandler> weak_ptr_factory_;
 
   // Holds grouped plug-ins. The key is the group identifier and
   // the value is the list of plug-ins belonging to the group.
   typedef base::hash_map<std::string, std::vector<const WebPluginInfo*> >
       PluginGroups;
 
@@ skipping 29 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveShowDetailsToPrefs",
       base::Bind(&PluginsDOMHandler::HandleSaveShowDetailsToPrefs,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getShowDetails",
       base::Bind(&PluginsDOMHandler::HandleGetShowDetails,
                  base::Unretained(this)));
 }
 
 void PluginsDOMHandler::HandleRequestPluginsData(const ListValue* args) {
-  GetPluginFinder();
+  LoadPlugins();
 }
 
 void PluginsDOMHandler::HandleEnablePluginMessage(const ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   // Be robust in accepting badness since plug-ins display HTML (hence
   // JavaScript).
   if (args->GetSize() != 3) {
     NOTREACHED();
     return;
@@ skipping 78 matching lines @@
   // whitelisted by the user from automatically whitelisted ones.
   DictionaryPrefUpdate update(profile->GetPrefs(),
                               prefs::kContentSettingsPluginWhitelist);
   update->SetBoolean(plugin, allowed);
 }
 
 void PluginsDOMHandler::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED, type);
-  GetPluginFinder();
+  LoadPlugins();
 }
 
-void PluginsDOMHandler::GetPluginFinder() {
+void PluginsDOMHandler::LoadPlugins() {
   if (weak_ptr_factory_.HasWeakPtrs())
     return;
 
-  PluginFinder::Get(base::Bind(&PluginsDOMHandler::LoadPlugins,
-                               weak_ptr_factory_.GetWeakPtr()));
-}
-
-void PluginsDOMHandler::LoadPlugins(PluginFinder* plugin_finder) {
   PluginService::GetInstance()->GetPlugins(
       base::Bind(&PluginsDOMHandler::PluginsLoaded,
-          weak_ptr_factory_.GetWeakPtr(), plugin_finder));
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PluginsDOMHandler::PluginsLoaded(
-    PluginFinder* plugin_finder,
     const std::vector<webkit::WebPluginInfo>& plugins) {
   Profile* profile = Profile::FromWebUI(web_ui());
   PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile);
 
   ContentSettingsPattern wildcard = ContentSettingsPattern::Wildcard();
 
+  PluginFinder* plugin_finder = PluginFinder::GetInstance();
   // Group plug-ins by identifier. This is done to be able to display
   // the plug-ins in UI in a grouped fashion.
   PluginGroups groups;
   for (size_t i = 0; i < plugins.size(); ++i) {
-    PluginInstaller* installer = plugin_finder->GetPluginInstaller(plugins[i]);
-    groups[installer->identifier()].push_back(&plugins[i]);
+    PluginMetadata* plugin = plugin_finder->GetPluginMetadata(plugins[i]);
+    groups[plugin->identifier()].push_back(&plugins[i]);
   }
 
   // Construct DictionaryValues to return to UI.
   ListValue* plugin_groups_data = new ListValue();
   for (PluginGroups::const_iterator it = groups.begin();
       it != groups.end(); ++it) {
     const std::vector<const WebPluginInfo*>& group_plugins = it->second;
     ListValue* plugin_files = new ListValue();
-    PluginInstaller* plugin_installer =
-        plugin_finder->GetPluginInstaller(*group_plugins[0]);
-    string16 group_name = plugin_installer->name();
-    std::string group_identifier = plugin_installer->identifier();
+    PluginMetadata* plugin_metadata =
+        plugin_finder->GetPluginMetadata(*group_plugins[0]);
+    string16 group_name = plugin_metadata->name();
+    std::string group_identifier = plugin_metadata->identifier();
     bool group_enabled = false;
     bool all_plugins_enabled_by_policy = true;
     bool all_plugins_disabled_by_policy = true;
     const WebPluginInfo* active_plugin = NULL;
     for (size_t j = 0; j < group_plugins.size(); ++j) {
       const WebPluginInfo& group_plugin = *group_plugins[j];
 
       DictionaryValue* plugin_file = new DictionaryValue();
       plugin_file->SetString("name", group_plugin.name);
       plugin_file->SetString("description", group_plugin.desc);
@@ skipping 54 matching lines @@
     }
     DictionaryValue* group_data = new DictionaryValue();
 
     group_data->Set("plugin_files", plugin_files);
     group_data->SetString("name", group_name);
     group_data->SetString("id", group_identifier);
     group_data->SetString("description", active_plugin->desc);
     group_data->SetString("version", active_plugin->version);
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
-    PluginInstaller* installer =
-        plugin_finder->FindPluginWithIdentifier(group_identifier);
-    if (installer) {
-      bool out_of_date = installer->GetSecurityStatus(*active_plugin) ==
-                         PluginInstaller::SECURITY_STATUS_OUT_OF_DATE;
-      group_data->SetBoolean("critical", out_of_date);
-      group_data->SetString("update_url", installer->plugin_url().spec());
-    }
+    bool out_of_date = plugin_metadata->GetSecurityStatus(*active_plugin) ==
+        PluginMetadata::SECURITY_STATUS_OUT_OF_DATE;
+    group_data->SetBoolean("critical", out_of_date);
+    group_data->SetString("update_url", plugin_metadata->plugin_url().spec());
 #endif
 
     std::string enabled_mode;
     if (all_plugins_enabled_by_policy) {
       enabled_mode = "enabledByPolicy";
     } else if (all_plugins_disabled_by_policy) {
       enabled_mode = "disabledByPolicy";
     } else if (group_enabled) {
       enabled_mode = "enabledByUser";
     } else {
@@ skipping 43 matching lines @@
 void PluginsUI::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kPluginsShowDetails,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kPluginsShowSetReaderDefaultInfobar,
                              true,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterDictionaryPref(prefs::kContentSettingsPluginWhitelist,
                                 PrefService::SYNCABLE_PREF);
 }