Policy: Re-enabled plugin still disabled

chrome/browser/plugin_updater.cc

 // Copyright (c) 2010 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/plugin_updater.h"
 
 #include <set>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 22 matching lines @@
     : enable_internal_pdf_(true),
       notify_pending_(false) {
 }
 
 DictionaryValue* PluginUpdater::CreatePluginFileSummary(
     const webkit::npapi::WebPluginInfo& plugin) {
   DictionaryValue* data = new DictionaryValue();
   data->SetString("path", plugin.path.value());
   data->SetString("name", plugin.name);
   data->SetString("version", plugin.version);
-  data->SetBoolean("enabled", plugin.enabled);
+  data->SetBoolean("enabled", webkit::npapi::IsPluginEnabled(plugin));
   return data;
 }
 
 // static
 ListValue* PluginUpdater::GetPluginGroupsData() {
   std::vector<webkit::npapi::PluginGroup> plugin_groups;
   webkit::npapi::PluginList::Singleton()->GetPluginGroups(true, &plugin_groups);
 
   // Construct DictionaryValues to return to the UI
   ListValue* plugin_groups_data = new ListValue();
   for (size_t i = 0; i < plugin_groups.size(); ++i) {
     plugin_groups_data->Append(plugin_groups[i].GetDataForUI());
   }
   return plugin_groups_data;
 }
 
 void PluginUpdater::EnablePluginGroup(bool enable, const string16& group_name) {
-  if (webkit::npapi::PluginGroup::IsPluginNameDisabledByPolicy(group_name))
-    enable = false;
   webkit::npapi::PluginList::Singleton()->EnableGroup(enable, group_name);
   NotifyPluginStatusChanged();
 }
 
-void PluginUpdater::EnablePluginFile(bool enable,
-                                     const FilePath::StringType& path) {
+void PluginUpdater::EnablePlugin(bool enable,
+                                 const FilePath::StringType& path) {
   FilePath file_path(path);
-  if (enable &&
-      !webkit::npapi::PluginGroup::IsPluginPathDisabledByPolicy(file_path))
+  if (enable)
     webkit::npapi::PluginList::Singleton()->EnablePlugin(file_path);
   else
     webkit::npapi::PluginList::Singleton()->DisablePlugin(file_path);
 
   NotifyPluginStatusChanged();
 }
 
 void PluginUpdater::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
@@ skipping 103 matching lines @@
           found_internal_pdf = true;
           if (!enabled) {
             if (force_enable_internal_pdf) {
               enabled = true;
               plugin->SetBoolean("enabled", true);
             } else if (force_internal_pdf_for_this_run) {
               enabled = true;
             }
           }
         }
-        if (!enabled)
+        if (!enabled) {

[jam, 2011/01/19 20:22:09]

nit: no need to add the brace brackets, to be consistent with the rest of the
file

[pastarmovj, 2011/01/19 23:39:17]

Done.

           webkit::npapi::PluginList::Singleton()->DisablePlugin(plugin_path);
+        }
       } else if (!enabled && plugin->GetString("name", &group_name)) {
         // Don't disable this group if it's for the pdf plugin and we just
         // forced it on.
         if (force_enable_internal_pdf && pdf_group_name == group_name)
           continue;
 
         // Otherwise this is a list of groups.
         EnablePluginGroup(false, group_name);
       }
     }
@@ skipping 36 matching lines @@
 void PluginUpdater::GetPreferencesDataOnFileThread(void* profile) {
   std::vector<webkit::npapi::WebPluginInfo> plugins;
   webkit::npapi::PluginList::Singleton()->GetPlugins(false, &plugins);
 
   std::vector<webkit::npapi::PluginGroup> groups;
   webkit::npapi::PluginList::Singleton()->GetPluginGroups(false, &groups);
 
   BrowserThread::PostTask(
     BrowserThread::UI,
     FROM_HERE,
-    NewRunnableFunction(
-        &PluginUpdater::OnUpdatePreferences,
-        static_cast<Profile*>(profile), plugins, groups));
+    NewRunnableFunction(&PluginUpdater::OnUpdatePreferences,
+                        static_cast<Profile*>(profile),
+                        plugins, groups));
 }
 
 void PluginUpdater::OnUpdatePreferences(
     Profile* profile,
     const std::vector<webkit::npapi::WebPluginInfo>& plugins,
     const std::vector<webkit::npapi::PluginGroup>& groups) {
   ListValue* plugins_list = profile->GetPrefs()->GetMutableList(
       prefs::kPluginsPluginsList);
   plugins_list->Clear();
 
   FilePath internal_dir;
   if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &internal_dir))
     profile->GetPrefs()->SetFilePath(prefs::kPluginsLastInternalDirectory,
                                      internal_dir);
 
   // Add the plugin files.
-  for (std::vector<webkit::npapi::WebPluginInfo>::const_iterator it =
-           plugins.begin();
-       it != plugins.end();
-       ++it) {
-    plugins_list->Append(CreatePluginFileSummary(*it));
+  for (size_t i = 0; i < plugins.size(); ++i) {
+    DictionaryValue* summary = CreatePluginFileSummary(plugins[i]);
+    // If the plugin is disabled only by policy don't store this state in the
+    // user pref store.
+    if (plugins[i].enabled ==
+        webkit::npapi::WebPluginInfo::USER_ENABLED_POLICY_DISABLED) {
+      summary->SetBoolean("enabled", true);
+    }
+    bool enabled_val;
+    summary->GetBoolean("enabled", &enabled_val);
+    plugins_list->Append(summary);
   }
 
   // Add the groups as well.
   for (size_t i = 0; i < groups.size(); ++i) {
-    plugins_list->Append(groups[i].GetSummary());
+      DictionaryValue* summary = groups[i].GetSummary();
+      // If the plugin is disabled only by policy don't store this state in the
+      // user pref store.
+      if (!groups[i].Enabled() &&
+          webkit::npapi::PluginGroup::IsPluginNameDisabledByPolicy(
+              groups[i].GetGroupName()))
+        summary->SetBoolean("enabled", true);
+      plugins_list->Append(summary);
   }
 }
 
 void PluginUpdater::NotifyPluginStatusChanged() {
   if (notify_pending_)
     return;
   notify_pending_ = true;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       NewRunnableFunction(&PluginUpdater::OnNotifyPluginStatusChanged));
 }
 
 void PluginUpdater::OnNotifyPluginStatusChanged() {
   GetInstance()->notify_pending_ = false;
   NotificationService::current()->Notify(
       NotificationType::PLUGIN_ENABLE_STATUS_CHANGED,
       Source<PluginUpdater>(GetInstance()),
       NotificationService::NoDetails());
 }
 
 /*static*/
 PluginUpdater* PluginUpdater::GetInstance() {
   return Singleton<PluginUpdater>::get();
 }