Move |requires_authorization| flag for plug-ins out of webkit/

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>
 
@@ skipping 26 matching lines @@
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/plugins/npapi/plugin_group.h"
 
+#if defined(ENABLE_PLUGIN_INSTALLATION)
+#include "chrome/browser/plugin_finder.h"
+#include "chrome/browser/plugin_installer.h"
+#else
+// Forward-declare PluginFinder. It's never actually used, but we pass a NULL
+// pointer instead.
+class PluginFinder;
+#endif
+
 using content::PluginService;
 using content::WebContents;
 using content::WebUIMessageHandler;
 using webkit::npapi::PluginGroup;
 using webkit::WebPluginInfo;
 
 namespace {
 
 ChromeWebUIDataSource* CreatePluginsUIHTMLSource() {
   ChromeWebUIDataSource* source =
@@ skipping 85 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 LoadPlugins();
+  void GetPluginFinder();
+
+  // Called when we have a PluginFinder and need to load the list of plug-ins.
+  void LoadPlugins(PluginFinder* plugin_finder);
 
   // Called on the UI thread when the plugin information is ready.
-  void PluginsLoaded(const std::vector<PluginGroup>& groups);
+  void PluginsLoaded(PluginFinder* plugin_finder,
+                     const std::vector<PluginGroup>& groups);
 
   content::NotificationRegistrar registrar_;
 
   base::WeakPtrFactory<PluginsDOMHandler> weak_ptr_factory_;
 
   // This pref guards the value whether about:plugins is in the details mode or
   // not.
   BooleanPrefMember show_details_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginsDOMHandler);
@@ skipping 24 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) {
-  LoadPlugins();
+  GetPluginFinder();
 }
 
 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 77 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);
-  LoadPlugins();
+  GetPluginFinder();
 }
 
-void PluginsDOMHandler::LoadPlugins() {
+void PluginsDOMHandler::GetPluginFinder() {
   if (weak_ptr_factory_.HasWeakPtrs())
     return;
 
+#if defined(ENABLE_PLUGIN_INSTALLATION)
+  PluginFinder::Get(base::Bind(&PluginsDOMHandler::LoadPlugins,
+                               weak_ptr_factory_.GetWeakPtr()));
+#else
+  LoadPlugins(NULL);
+#endif
+}
+
+void PluginsDOMHandler::LoadPlugins(PluginFinder* plugin_finder) {
   PluginService::GetInstance()->GetPluginGroups(
       base::Bind(&PluginsDOMHandler::PluginsLoaded,
-          weak_ptr_factory_.GetWeakPtr()));
+          weak_ptr_factory_.GetWeakPtr(), plugin_finder));
 }
 
-void PluginsDOMHandler::PluginsLoaded(const std::vector<PluginGroup>& groups) {
+void PluginsDOMHandler::PluginsLoaded(PluginFinder* plugin_finder,
+                                      const std::vector<PluginGroup>& groups) {
   Profile* profile = Profile::FromWebUI(web_ui());
-  PluginPrefs* plugin_prefs =
-      PluginPrefs::GetForProfile(profile);
+  PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile);
 
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
   ContentSettingsPattern wildcard = ContentSettingsPattern::Wildcard();
 
   // Construct DictionaryValues to return to the UI
   ListValue* plugin_groups_data = new ListValue();
   for (size_t i = 0; i < groups.size(); ++i) {
     const PluginGroup& group = groups[i];
     if (group.IsEmpty())
       continue;
@@ skipping 65 matching lines @@
       plugin_files->Append(plugin_file);
     }
     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);
     group_data->SetBoolean("critical", group.IsVulnerable(*active_plugin));
-    group_data->SetString("update_url", group.GetUpdateURL());
+
+    std::string update_url;
+#if defined(ENABLE_PLUGIN_INSTALLATION)
+    PluginInstaller* installer =
+        plugin_finder->FindPluginWithIdentifier(group.identifier());
+    if (installer)
+      update_url = installer->plugin_url().spec();
+#endif
+    group_data->SetString("update_url", update_url);
 
     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 {
       enabled_mode = "disabledByUser";
     }
     group_data->SetString("enabledMode", enabled_mode);
 
-    // TODO(bauerb): We should have a method on HostContentSettinsMap for this.
+    // TODO(bauerb): We should have a method on HostContentSettingsMap for this.
     bool always_allowed = false;
     ContentSettingsForOneType settings;
     map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_PLUGINS,
                                group.identifier(), &settings);
     for (ContentSettingsForOneType::const_iterator it = settings.begin();
          it != settings.end(); ++it) {
       if (it->primary_pattern == wildcard &&
           it->secondary_pattern == wildcard &&
           it->setting == CONTENT_SETTING_ALLOW) {
         always_allowed = true;
@@ skipping 36 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);
 }