Merge a bunch of CLs to whitelist the Google Talk plug-in when turning on click-to-play.

chrome/browser/ui/webui/plugins_ui.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/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/content_settings/host_content_settings_map.h"
 #include "chrome/browser/plugin_prefs.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/prefs/pref_service.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"
 #include "chrome/common/chrome_paths.h"
@@ skipping 42 matching lines @@
   source->AddLocalizedString("pluginType", IDS_PLUGINS_TYPE);
   source->AddLocalizedString("pluginMimeTypes", IDS_PLUGINS_MIME_TYPES);
   source->AddLocalizedString("pluginMimeTypesMimeType",
                              IDS_PLUGINS_MIME_TYPES_MIME_TYPE);
   source->AddLocalizedString("pluginMimeTypesDescription",
                              IDS_PLUGINS_MIME_TYPES_DESCRIPTION);
   source->AddLocalizedString("pluginMimeTypesFileExtensions",
                              IDS_PLUGINS_MIME_TYPES_FILE_EXTENSIONS);
   source->AddLocalizedString("disable", IDS_PLUGINS_DISABLE);
   source->AddLocalizedString("enable", IDS_PLUGINS_ENABLE);
+  source->AddLocalizedString("alwaysAllowed", IDS_EXCEPTIONS_ALLOW_BUTTON);
   source->AddLocalizedString("noPlugins", IDS_PLUGINS_NO_PLUGINS);
 
   source->set_json_path("strings.js");
   source->add_resource_path("plugins.js", IDR_PLUGINS_JS);
   source->set_default_resource(IDR_PLUGINS_HTML);
   return source;
 }
 
 string16 PluginTypeToString(int type) {
   // The type is stored as an |int|, but doing the switch on the right
@@ skipping 37 matching lines @@
 
   // Callback for the "enablePlugin" message.
   void HandleEnablePluginMessage(const ListValue* args);
 
   // Callback for the "saveShowDetailsToPrefs" message.
   void HandleSaveShowDetailsToPrefs(const ListValue* args);
 
   // Calback for the "getShowDetails" message.
   void HandleGetShowDetails(const ListValue* args);
 
+  // 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();
 
   // Called on the UI thread when the plugin information is ready.
@@ skipping 23 matching lines @@
   registrar_.Add(this,
                  chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED,
                  content::Source<Profile>(profile));
 
   web_ui()->RegisterMessageCallback("requestPluginsData",
       base::Bind(&PluginsDOMHandler::HandleRequestPluginsData,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("enablePlugin",
       base::Bind(&PluginsDOMHandler::HandleEnablePluginMessage,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("setPluginAlwaysAllowed",
+      base::Bind(&PluginsDOMHandler::HandleSetPluginAlwaysAllowed,
+                 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();
 }
 
 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)
+  if (args->GetSize() != 3) {
+    NOTREACHED();
     return;
+  }
 
   std::string enable_str;
   std::string is_group_str;
-  if (!args->GetString(1, &enable_str) || !args->GetString(2, &is_group_str))
+  if (!args->GetString(1, &enable_str) || !args->GetString(2, &is_group_str)) {
+    NOTREACHED();
     return;
+  }
   bool enable = enable_str == "true";
 
   PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile);
   if (is_group_str == "true") {
     string16 group_name;
-    if (!args->GetString(0, &group_name))
+    if (!args->GetString(0, &group_name)) {
+      NOTREACHED();
       return;
+    }
 
     plugin_prefs->EnablePluginGroup(enable, group_name);
     if (enable) {
       // See http://crbug.com/50105 for background.
       string16 adobereader = ASCIIToUTF16(
           PluginGroup::kAdobeReaderGroupName);
       string16 internalpdf =
           ASCIIToUTF16(chrome::ChromeContentClient::kPDFPluginName);
       if (group_name == adobereader)
         plugin_prefs->EnablePluginGroup(false, internalpdf);
       else if (group_name == internalpdf)
         plugin_prefs->EnablePluginGroup(false, adobereader);
     }
   } else {
     FilePath::StringType file_path;
-    if (!args->GetString(0, &file_path))
+    if (!args->GetString(0, &file_path)) {
+      NOTREACHED();
       return;
+    }
     bool result = plugin_prefs->EnablePlugin(enable, FilePath(file_path));
     DCHECK(result);
   }
 }
 
 void PluginsDOMHandler::HandleSaveShowDetailsToPrefs(const ListValue* args) {
   std::string details_mode;
   if (!args->GetString(0, &details_mode)) {
     NOTREACHED();
     return;
   }
   show_details_.SetValue(details_mode == "true");
 }
 
 void PluginsDOMHandler::HandleGetShowDetails(const ListValue* args) {
   base::FundamentalValue show_details(show_details_.GetValue());
   web_ui()->CallJavascriptFunction("loadShowDetailsFromPrefs", show_details);
 }
 
+void PluginsDOMHandler::HandleSetPluginAlwaysAllowed(const ListValue* args) {
+  // Be robust in the input parameters, but crash in a Debug build.
+  if (args->GetSize() != 2) {
+    NOTREACHED();
+    return;
+  }
+
+  std::string plugin;
+  bool allowed = false;
+  if (!args->GetString(0, &plugin) || !args->GetBoolean(1, &allowed)) {
+    NOTREACHED();
+    return;
+  }
+  Profile* profile = Profile::FromWebUI(web_ui());
+  profile->GetHostContentSettingsMap()->SetContentSetting(
+      ContentSettingsPattern::Wildcard(),
+      ContentSettingsPattern::Wildcard(),
+      CONTENT_SETTINGS_TYPE_PLUGINS,
+      plugin,
+      allowed ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_DEFAULT);
+
+  // Keep track of the whitelist separately, so that we can distinguish plug-ins
+  // 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();
 }
 
 void PluginsDOMHandler::LoadPlugins() {
   if (weak_ptr_factory_.HasWeakPtrs())
     return;
 
   PluginService::GetInstance()->GetPluginGroups(
       base::Bind(&PluginsDOMHandler::PluginsLoaded,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PluginsDOMHandler::PluginsLoaded(const std::vector<PluginGroup>& groups) {
+  Profile* profile = Profile::FromWebUI(web_ui());
   PluginPrefs* plugin_prefs =
-      PluginPrefs::GetForProfile(Profile::FromWebUI(web_ui()));
+      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;
     ListValue* plugin_files = new ListValue();
     string16 group_name = group.GetGroupName();
     bool group_enabled = false;
@@ skipping 58 matching lines @@
         }
       }
       plugin_file->SetString("enabledMode", enabled_mode);
 
       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 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.
+    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;
+        break;
+      }
+    }
+    group_data->SetBoolean("alwaysAllowed", always_allowed);
+
     plugin_groups_data->Append(group_data);
   }
   DictionaryValue results;
   results.Set("plugins", plugin_groups_data);
   web_ui()->CallJavascriptFunction("returnPluginsData", results);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // PluginsUI
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 PluginsUI::PluginsUI(content::WebUI* web_ui) : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new PluginsDOMHandler());
 
   // Set up the chrome://plugins/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   profile->GetChromeURLDataManager()->AddDataSource(
       CreatePluginsUIHTMLSource());
 }
 
-
 // static
 RefCountedMemory* PluginsUI::GetFaviconResourceBytes() {
   return ResourceBundle::GetSharedInstance().
       LoadDataResourceBytes(IDR_PLUGIN);
 }
 
 // static
 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);
 }