Revert r96364, it's breaking a NaCl test.

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>
 
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/plugin_prefs.h"
+#include "chrome/browser/plugin_updater.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_paths.h"
 #include "chrome/common/pref_names.h"
@@ skipping 88 matching lines @@
 
   // Calback for the "getShowDetails" message.
   void HandleGetShowDetails(const ListValue* args);
 
   // NotificationObserver method overrides
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
  private:
+  // This extra wrapper is used to ensure we don't leak the ListValue* pointer
+  // if the PluginsDOMHandler object goes away before the task on the UI thread
+  // to give it the plugin list runs.
+  struct ListWrapper {
+    ListValue* list;
+  };
   // Loads the plugins on the FILE thread.
-  static void LoadPluginsOnFileThread(
-      std::vector<webkit::npapi::PluginGroup>* groups, Task* task);
+  static void LoadPluginsOnFileThread(ListWrapper* wrapper, Task* task);
 
   // Used in conjunction with ListWrapper to avoid any memory leaks.
-  static void EnsurePluginGroupsDeleted(
-      std::vector<webkit::npapi::PluginGroup>* groups);
+  static void EnsureListDeleted(ListWrapper* wrapper);
 
   // 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<webkit::npapi::PluginGroup>* groups);
+  void PluginsLoaded(ListWrapper* wrapper);
 
   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);
 };
 
 PluginsDOMHandler::PluginsDOMHandler()
     : ALLOW_THIS_IN_INITIALIZER_LIST(get_plugins_factory_(this)) {
   registrar_.Add(this,
                  content::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED,
                  NotificationService::AllSources());
 }
 
 WebUIMessageHandler* PluginsDOMHandler::Attach(WebUI* web_ui) {
   PrefService* prefs = Profile::FromWebUI(web_ui)->GetPrefs();
 
-  show_details_.Init(prefs::kPluginsShowDetails, prefs, NULL);
+  show_details_.Init(prefs::kPluginsShowDetails, prefs, this);
 
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 void PluginsDOMHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("requestPluginsData",
       NewCallback(this, &PluginsDOMHandler::HandleRequestPluginsData));
   web_ui_->RegisterMessageCallback("enablePlugin",
       NewCallback(this, &PluginsDOMHandler::HandleEnablePluginMessage));
   web_ui_->RegisterMessageCallback("saveShowDetailsToPrefs",
@@ skipping 20 matching lines @@
   // 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);
+  PluginUpdater* plugin_updater = PluginUpdater::GetInstance();
   if (is_group_str == "true") {
     string16 group_name;
     if (!args->GetString(0, &group_name))
       return;
 
-    plugin_prefs->EnablePluginGroup(enable, group_name);
+    plugin_updater->EnablePluginGroup(enable, group_name);
     if (enable) {
       // See http://crbug.com/50105 for background.
       string16 adobereader = ASCIIToUTF16(
           webkit::npapi::PluginGroup::kAdobeReaderGroupName);
       string16 internalpdf =
           ASCIIToUTF16(chrome::ChromeContentClient::kPDFPluginName);
       if (group_name == adobereader) {
-        plugin_prefs->EnablePluginGroup(false, internalpdf);
+        plugin_updater->EnablePluginGroup(false, internalpdf);
       } else if (group_name == internalpdf) {
-        plugin_prefs->EnablePluginGroup(false, adobereader);
+        plugin_updater->EnablePluginGroup(false, adobereader);
       }
     }
   } else {
     FilePath::StringType file_path;
     if (!args->GetString(0, &file_path))
       return;
 
-    plugin_prefs->EnablePlugin(enable, FilePath(file_path));
+    plugin_updater->EnablePlugin(enable, 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);
+  plugin_updater->UpdatePreferences(profile, 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(content::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED, type);
   LoadPlugins();
 }
 
-void PluginsDOMHandler::LoadPluginsOnFileThread(
-    std::vector<webkit::npapi::PluginGroup>* groups,
-    Task* task) {
-  webkit::npapi::PluginList::Singleton()->GetPluginGroups(true, groups);
-
+void PluginsDOMHandler::LoadPluginsOnFileThread(ListWrapper* wrapper,
+                                                Task* task) {
+  wrapper->list = PluginUpdater::GetInstance()->GetPluginGroupsData();
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, task);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      NewRunnableFunction(&PluginsDOMHandler::EnsurePluginGroupsDeleted,
-                          groups));
+      NewRunnableFunction(&PluginsDOMHandler::EnsureListDeleted, wrapper));
 }
 
-void PluginsDOMHandler::EnsurePluginGroupsDeleted(
-    std::vector<webkit::npapi::PluginGroup>* groups) {
-  delete groups;
+void PluginsDOMHandler::EnsureListDeleted(ListWrapper* wrapper) {
+  delete wrapper->list;
+  delete wrapper;
 }
 
 void PluginsDOMHandler::LoadPlugins() {
   if (!get_plugins_factory_.empty())
     return;
 
-  std::vector<webkit::npapi::PluginGroup>* groups =
-      new std::vector<webkit::npapi::PluginGroup>;
+  ListWrapper* wrapper = new ListWrapper;
+  wrapper->list = NULL;
   Task* task = get_plugins_factory_.NewRunnableMethod(
-          &PluginsDOMHandler::PluginsLoaded, groups);
+          &PluginsDOMHandler::PluginsLoaded, wrapper);
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       NewRunnableFunction(
-          &PluginsDOMHandler::LoadPluginsOnFileThread, groups, task));
+          &PluginsDOMHandler::LoadPluginsOnFileThread, wrapper, task));
 }
 
-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) {
-    plugin_groups_data->Append((*groups)[i].GetDataForUI());
-    // TODO(bauerb): Fetch plugin enabled state from PluginPrefs.
-  }
+void PluginsDOMHandler::PluginsLoaded(ListWrapper* wrapper) {
   DictionaryValue results;
-  results.Set("plugins", plugin_groups_data);
+  results.Set("plugins", wrapper->list);
+  wrapper->list = NULL;  // So it doesn't get deleted.
   web_ui_->CallJavascriptFunction("returnPluginsData", results);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // PluginsUI
 //
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 25 matching lines @@
   prefs->RegisterBooleanPref(prefs::kPluginsEnabledInternalPDF,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kPluginsShowDetails,
                              false,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kPluginsShowSetReaderDefaultInfobar,
                              true,
                              PrefService::UNSYNCABLE_PREF);
 }