Revert 101269 - Store plug-in enabled/disabled state in PluginPrefs instead of WebPluginInfo, to ...

chrome/browser/ui/webui/plugins_ui.cc

 // Copyright (c) 2011 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 18 matching lines @@
 #include "content/browser/browser_thread.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_service.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/resource/resource_bundle.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 
-using webkit::npapi::PluginGroup;
-using webkit::WebPluginInfo;
-
 namespace {
 
 ChromeWebUIDataSource* CreatePluginsUIHTMLSource(bool enable_controls) {
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIPluginsHost);
 
   source->AddLocalizedString("pluginsTitle", IDS_PLUGINS_TITLE);
   source->AddLocalizedString("pluginsDetailsModeLink",
                              IDS_PLUGINS_DETAILS_MODE_LINK);
   source->AddLocalizedString("pluginsNoneInstalled",
@@ skipping 69 matching lines @@
   void HandleGetShowDetails(const ListValue* args);
 
   // NotificationObserver method overrides
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
  private:
   // Loads the plugins on the FILE thread.
   static void LoadPluginsOnFileThread(
-      std::vector<PluginGroup>* groups, Task* task);
+      std::vector<webkit::npapi::PluginGroup>* groups, Task* task);
 
   // Used in conjunction with ListWrapper to avoid any memory leaks.
   static void EnsurePluginGroupsDeleted(
-      std::vector<PluginGroup>* groups);
+      std::vector<webkit::npapi::PluginGroup>* groups);
 
   // Call this to start getting the plugins on the UI thread.
   void LoadPlugins();
 
   // Called on the UI thread when the plugin information is ready.
-  void PluginsLoaded(const std::vector<PluginGroup>* groups);
+  void PluginsLoaded(const std::vector<webkit::npapi::PluginGroup>* groups);
 
   NotificationRegistrar registrar_;
 
   ScopedRunnableMethodFactory<PluginsDOMHandler> get_plugins_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 25 matching lines @@
       NewCallback(this, &PluginsDOMHandler::HandleGetShowDetails));
 }
 
 void PluginsDOMHandler::HandleRequestPluginsData(const ListValue* args) {
   LoadPlugins();
 }
 
 void PluginsDOMHandler::HandleEnablePluginMessage(const ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui_);
 
+  // If a non-first-profile user tries to trigger these methods sneakily,
+  // forbid it.
+#if !defined(OS_CHROMEOS)
+  if (!profile->GetOriginalProfile()->first_launched())
+    return;
+#endif
+
   // Be robust in accepting badness since plug-ins display HTML (hence
   // JavaScript).
   if (args->GetSize() != 3)
     return;
 
   std::string enable_str;
   std::string is_group_str;
   if (!args->GetString(1, &enable_str) || !args->GetString(2, &is_group_str))
     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))
       return;
 
     plugin_prefs->EnablePluginGroup(enable, group_name);
     if (enable) {
       // See http://crbug.com/50105 for background.
       string16 adobereader = ASCIIToUTF16(
-          PluginGroup::kAdobeReaderGroupName);
+          webkit::npapi::PluginGroup::kAdobeReaderGroupName);
       string16 internalpdf =
           ASCIIToUTF16(chrome::ChromeContentClient::kPDFPluginName);
-      if (group_name == adobereader)
+      if (group_name == adobereader) {
         plugin_prefs->EnablePluginGroup(false, internalpdf);
-      else if (group_name == internalpdf)
+      } else if (group_name == internalpdf) {
         plugin_prefs->EnablePluginGroup(false, adobereader);
+      }
     }
   } else {
     FilePath::StringType file_path;
     if (!args->GetString(0, &file_path))
       return;
+
     plugin_prefs->EnablePlugin(enable, FilePath(file_path));
   }
+
+  // TODO(viettrungluu): We might also want to ensure that the plugins
+  // list is always written to prefs even when the user hasn't disabled a
+  // plugin. <http://crbug.com/39101>
+  plugin_prefs->UpdatePreferences(0);
 }
 
 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::Observe(int type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED, type);
   LoadPlugins();
 }
 
 void PluginsDOMHandler::LoadPluginsOnFileThread(
-    std::vector<PluginGroup>* groups,
+    std::vector<webkit::npapi::PluginGroup>* groups,
     Task* task) {
   webkit::npapi::PluginList::Singleton()->GetPluginGroups(true, groups);
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, task);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       NewRunnableFunction(&PluginsDOMHandler::EnsurePluginGroupsDeleted,
                           groups));
 }
 
 void PluginsDOMHandler::EnsurePluginGroupsDeleted(
-    std::vector<PluginGroup>* groups) {
+    std::vector<webkit::npapi::PluginGroup>* groups) {
   delete groups;
 }
 
 void PluginsDOMHandler::LoadPlugins() {
   if (!get_plugins_factory_.empty())
     return;
 
-  std::vector<PluginGroup>* groups = new std::vector<PluginGroup>;
+  std::vector<webkit::npapi::PluginGroup>* groups =
+      new std::vector<webkit::npapi::PluginGroup>;
   Task* task = get_plugins_factory_.NewRunnableMethod(
           &PluginsDOMHandler::PluginsLoaded, groups);
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       NewRunnableFunction(
           &PluginsDOMHandler::LoadPluginsOnFileThread, groups, task));
 }
 
-void PluginsDOMHandler::PluginsLoaded(const std::vector<PluginGroup>* groups) {
-  PluginPrefs* plugin_prefs =
-      PluginPrefs::GetForProfile(Profile::FromWebUI(web_ui_));
-
-  bool all_plugins_enabled_by_policy = true;
-  bool all_plugins_disabled_by_policy = true;
-
+void PluginsDOMHandler::PluginsLoaded(
+    const std::vector<webkit::npapi::PluginGroup>* groups) {
   // Construct DictionaryValues to return to the UI
   ListValue* plugin_groups_data = new ListValue();
   for (size_t i = 0; i < groups->size(); ++i) {
-    ListValue* plugin_files = new ListValue();
-    const PluginGroup& group = (*groups)[i];
-    string16 group_name = group.GetGroupName();
-    bool group_enabled = false;
-    const WebPluginInfo* active_plugin = NULL;
-    for (size_t j = 0; j < group.web_plugin_infos().size(); ++j) {
-      const WebPluginInfo& group_plugin = group.web_plugin_infos()[j];
-
-      DictionaryValue* plugin_file = new DictionaryValue();
-      plugin_file->SetString("name", group_plugin.name);
-      plugin_file->SetString("description", group_plugin.desc);
-      plugin_file->SetString("path", group_plugin.path.value());
-      plugin_file->SetString("version", group_plugin.version);
-
-      ListValue* mime_types = new ListValue();
-      const std::vector<webkit::WebPluginMimeType>& plugin_mime_types =
-          group_plugin.mime_types;
-      for (size_t k = 0; k < plugin_mime_types.size(); ++k) {
-        DictionaryValue* mime_type = new DictionaryValue();
-        mime_type->SetString("mimeType", plugin_mime_types[k].mime_type);
-        mime_type->SetString("description", plugin_mime_types[k].description);
-
-        ListValue* file_extensions = new ListValue();
-        const std::vector<std::string>& mime_file_extensions =
-            plugin_mime_types[k].file_extensions;
-        for (size_t l = 0; l < mime_file_extensions.size(); ++l)
-          file_extensions->Append(new StringValue(mime_file_extensions[l]));
-        mime_type->Set("fileExtensions", file_extensions);
-
-        mime_types->Append(mime_type);
-      }
-      plugin_file->Set("mimeTypes", mime_types);
-
-      bool plugin_enabled = plugin_prefs->IsPluginEnabled(group_plugin);
-
-      if (!active_plugin || (plugin_enabled && !group_enabled))
-        active_plugin = &group_plugin;
-      group_enabled = plugin_enabled || group_enabled;
-
-      std::string enabled_mode;
-      PluginPrefs::PolicyStatus plugin_status =
-          plugin_prefs->PolicyStatusForPlugin(group_plugin.name);
-      PluginPrefs::PolicyStatus group_status =
-          plugin_prefs->PolicyStatusForPlugin(group_name);
-      if (plugin_status == PluginPrefs::POLICY_ENABLED ||
-          group_status == PluginPrefs::POLICY_ENABLED) {
-        enabled_mode = "enabledByPolicy";
-      } else {
-        all_plugins_enabled_by_policy = false;
-        if (plugin_status == PluginPrefs::POLICY_DISABLED ||
-          group_status == PluginPrefs::POLICY_DISABLED) {
-          enabled_mode = "disabledByPolicy";
-        } else {
-          all_plugins_disabled_by_policy = false;
-          if (plugin_enabled) {
-            enabled_mode = "enabledByUser";
-          } else {
-            enabled_mode = "disabledByUser";
-          }
-        }
-      }
-      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("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);
-
-    plugin_groups_data->Append(group_data);
+    plugin_groups_data->Append((*groups)[i].GetDataForUI());
+    // TODO(bauerb): Fetch plugin enabled state from PluginPrefs.
   }
   DictionaryValue results;
   results.Set("plugins", plugin_groups_data);
   web_ui_->CallJavascriptFunction("returnPluginsData", results);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // PluginsUI
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 PluginsUI::PluginsUI(TabContents* contents) : ChromeWebUI(contents) {
   AddMessageHandler((new PluginsDOMHandler())->Attach(this));
 
   // Set up the chrome://plugins/ source.
-  // TODO(bauerb): Remove |enable_controls| & co.
   bool enable_controls = true;
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
+#if !defined(OS_CHROMEOS)
+  enable_controls = profile->GetOriginalProfile()->first_launched();
+#endif
   profile->GetChromeURLDataManager()->AddDataSource(
       CreatePluginsUIHTMLSource(enable_controls));
 }
 
 
 // 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);
 }