chrome/browser/plugins/plugin_prefs.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/plugins/plugin_prefs.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/path_service.h"
  14 #include "base/prefs/scoped_user_pref_update.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/values.h"
  18 #include "build/build_config.h"
  19 #include "chrome/browser/browser_process.h"
  20 #include "chrome/browser/chrome_notification_types.h"
  21 #include "chrome/browser/plugins/plugin_installer.h"
  22 #include "chrome/browser/plugins/plugin_metadata.h"
  23 #include "chrome/browser/plugins/plugin_prefs_factory.h"
  24 #include "chrome/browser/profiles/profile.h"
  25 #include "chrome/common/chrome_constants.h"
  26 #include "chrome/common/chrome_content_client.h"
  27 #include "chrome/common/chrome_paths.h"
  28 #include "chrome/common/chrome_switches.h"
  29 #include "chrome/common/pref_names.h"
  30 #include "components/keyed_service/core/keyed_service.h"
  31 #include "content/public/browser/browser_thread.h"
  32 #include "content/public/browser/notification_service.h"
  33 #include "content/public/browser/plugin_service.h"
  34 #include "content/public/common/webplugininfo.h"
  35
  36 using content::BrowserThread;
  37 using content::PluginService;
  38
  39 namespace {
  40
  41 bool IsComponentUpdatedPepperFlash(const base::FilePath& plugin) {
  42   if (plugin.BaseName().value() == chrome::kPepperFlashPluginFilename) {
  43     base::FilePath component_updated_pepper_flash_dir;
  44     if (PathService::Get(chrome::DIR_COMPONENT_UPDATED_PEPPER_FLASH_PLUGIN,
  45                          &component_updated_pepper_flash_dir) &&
  46         component_updated_pepper_flash_dir.IsParent(plugin)) {
  47       return true;
  48     }
  49   }
  50
  51   return false;
  52 }
  53
  54 }  // namespace
  55
  56 PluginPrefs::PluginState::PluginState() {
  57 }
  58
  59 PluginPrefs::PluginState::~PluginState() {
  60 }
  61
  62 bool PluginPrefs::PluginState::Get(const base::FilePath& plugin,
  63                                    bool* enabled) const {
  64   base::FilePath key = ConvertMapKey(plugin);
  65   std::map<base::FilePath, bool>::const_iterator iter = state_.find(key);
  66   if (iter != state_.end()) {
  67     *enabled = iter->second;
  68     return true;
  69   }
  70   return false;
  71 }
  72
  73 void PluginPrefs::PluginState::Set(const base::FilePath& plugin, bool enabled) {
  74   state_[ConvertMapKey(plugin)] = enabled;
  75 }
  76
  77 base::FilePath PluginPrefs::PluginState::ConvertMapKey(
  78     const base::FilePath& plugin) const {
  79   // Keep the state of component-updated and bundled Pepper Flash in sync.
  80   if (IsComponentUpdatedPepperFlash(plugin)) {
  81     base::FilePath bundled_pepper_flash;
  82     if (PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN,
  83                          &bundled_pepper_flash)) {
  84       return bundled_pepper_flash;
  85     }
  86   }
  87
  88   return plugin;
  89 }
  90
  91 // static
  92 scoped_refptr<PluginPrefs> PluginPrefs::GetForProfile(Profile* profile) {
  93   return PluginPrefsFactory::GetPrefsForProfile(profile);
  94 }
  95
  96 // static
  97 scoped_refptr<PluginPrefs> PluginPrefs::GetForTestingProfile(
  98     Profile* profile) {
  99   return static_cast<PluginPrefs*>(
 100       PluginPrefsFactory::GetInstance()->SetTestingFactoryAndUse(
 101           profile, &PluginPrefsFactory::CreateForTestingProfile).get());
 102 }
 103
 104 void PluginPrefs::EnablePluginGroup(bool enabled,
 105                                     const base::string16& group_name) {
 106   PluginService::GetInstance()->GetPlugins(
 107       base::Bind(&PluginPrefs::EnablePluginGroupInternal,
 108                  this, enabled, group_name));
 109 }
 110
 111 void PluginPrefs::EnablePluginGroupInternal(
 112     bool enabled,
 113     const base::string16& group_name,
 114     const std::vector<content::WebPluginInfo>& plugins) {
 115   base::AutoLock auto_lock(lock_);
 116   PluginFinder* finder = PluginFinder::GetInstance();
 117
 118   // Set the desired state for the group.
 119   plugin_group_state_[group_name] = enabled;
 120
 121   // Update the state for all plug-ins in the group.
 122   for (size_t i = 0; i < plugins.size(); ++i) {
 123     scoped_ptr<PluginMetadata> plugin(finder->GetPluginMetadata(plugins[i]));
 124     if (group_name != plugin->name())
 125       continue;
 126     plugin_state_.Set(plugins[i].path, enabled);
 127   }
 128
 129   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 130       base::Bind(&PluginPrefs::OnUpdatePreferences, this, plugins));
 131   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 132       base::Bind(&PluginPrefs::NotifyPluginStatusChanged, this));
 133 }
 134
 135 void PluginPrefs::EnablePlugin(
 136     bool enabled, const base::FilePath& path,
 137     const base::Callback<void(bool)>& callback) {
 138   PluginFinder* finder = PluginFinder::GetInstance();
 139   content::WebPluginInfo plugin;
 140   bool can_enable = true;
 141   if (PluginService::GetInstance()->GetPluginInfoByPath(path, &plugin)) {
 142     scoped_ptr<PluginMetadata> plugin_metadata(
 143         finder->GetPluginMetadata(plugin));
 144     PolicyStatus plugin_status = PolicyStatusForPlugin(plugin.name);
 145     PolicyStatus group_status = PolicyStatusForPlugin(plugin_metadata->name());
 146     if (enabled) {
 147       if (plugin_status == POLICY_DISABLED || group_status == POLICY_DISABLED)
 148         can_enable = false;
 149     } else {
 150       if (plugin_status == POLICY_ENABLED || group_status == POLICY_ENABLED)
 151         can_enable = false;
 152     }
 153   } else {
 154     NOTREACHED();
 155   }
 156
 157   if (!can_enable) {
 158     base::MessageLoop::current()->PostTask(FROM_HERE,
 159                                            base::Bind(callback, false));
 160     return;
 161   }
 162
 163   PluginService::GetInstance()->GetPlugins(
 164       base::Bind(&PluginPrefs::EnablePluginInternal, this,
 165                  enabled, path, finder, callback));
 166 }
 167
 168 void PluginPrefs::EnablePluginInternal(
 169     bool enabled,
 170     const base::FilePath& path,
 171     PluginFinder* plugin_finder,
 172     const base::Callback<void(bool)>& callback,
 173     const std::vector<content::WebPluginInfo>& plugins) {
 174   {
 175     // Set the desired state for the plug-in.
 176     base::AutoLock auto_lock(lock_);
 177     plugin_state_.Set(path, enabled);
 178   }
 179
 180   base::string16 group_name;
 181   for (size_t i = 0; i < plugins.size(); ++i) {
 182     if (plugins[i].path == path) {
 183       scoped_ptr<PluginMetadata> plugin_metadata(
 184           plugin_finder->GetPluginMetadata(plugins[i]));
 185       // set the group name for this plug-in.
 186       group_name = plugin_metadata->name();
 187       DCHECK_EQ(enabled, IsPluginEnabled(plugins[i]));
 188       break;
 189     }
 190   }
 191
 192   bool all_disabled = true;
 193   for (size_t i = 0; i < plugins.size(); ++i) {
 194     scoped_ptr<PluginMetadata> plugin_metadata(
 195         plugin_finder->GetPluginMetadata(plugins[i]));
 196     DCHECK(!plugin_metadata->name().empty());
 197     if (group_name == plugin_metadata->name()) {
 198       all_disabled = all_disabled && !IsPluginEnabled(plugins[i]);
 199     }
 200   }
 201
 202   if (!group_name.empty()) {
 203     // Update the state for the corresponding plug-in group.
 204     base::AutoLock auto_lock(lock_);
 205     plugin_group_state_[group_name] = !all_disabled;
 206   }
 207
 208   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 209       base::Bind(&PluginPrefs::OnUpdatePreferences, this, plugins));
 210   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 211       base::Bind(&PluginPrefs::NotifyPluginStatusChanged, this));
 212   callback.Run(true);
 213 }
 214
 215 PluginPrefs::PolicyStatus PluginPrefs::PolicyStatusForPlugin(
 216     const base::string16& name) const {
 217   base::AutoLock auto_lock(lock_);
 218   if (IsStringMatchedInSet(name, policy_enabled_plugin_patterns_)) {
 219     return POLICY_ENABLED;
 220   } else if (IsStringMatchedInSet(name, policy_disabled_plugin_patterns_) &&
 221              !IsStringMatchedInSet(
 222                  name, policy_disabled_plugin_exception_patterns_)) {
 223     return POLICY_DISABLED;
 224   } else {
 225     return NO_POLICY;
 226   }
 227 }
 228
 229 bool PluginPrefs::IsPluginEnabled(const content::WebPluginInfo& plugin) const {
 230   scoped_ptr<PluginMetadata> plugin_metadata(
 231       PluginFinder::GetInstance()->GetPluginMetadata(plugin));
 232   base::string16 group_name = plugin_metadata->name();
 233
 234   // Check if the plug-in or its group is enabled by policy.
 235   PolicyStatus plugin_status = PolicyStatusForPlugin(plugin.name);
 236   PolicyStatus group_status = PolicyStatusForPlugin(group_name);
 237   if (plugin_status == POLICY_ENABLED || group_status == POLICY_ENABLED)
 238     return true;
 239
 240   // Check if the plug-in or its group is disabled by policy.
 241   if (plugin_status == POLICY_DISABLED || group_status == POLICY_DISABLED)
 242     return false;
 243
 244   // If enabling NaCl, make sure the plugin is also enabled. See bug
 245   // http://code.google.com/p/chromium/issues/detail?id=81010 for more
 246   // information.
 247   // TODO(dspringer): When NaCl is on by default, remove this code.
 248   if ((plugin.name ==
 249        base::ASCIIToUTF16(ChromeContentClient::kNaClPluginName)) &&
 250       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableNaCl)) {
 251     return true;
 252   }
 253
 254   base::AutoLock auto_lock(lock_);
 255   // Check user preferences for the plug-in.
 256   bool plugin_enabled = false;
 257   if (plugin_state_.Get(plugin.path, &plugin_enabled))
 258     return plugin_enabled;
 259
 260   // Check user preferences for the plug-in group.
 261   std::map<base::string16, bool>::const_iterator group_it(
 262       plugin_group_state_.find(group_name));
 263   if (group_it != plugin_group_state_.end())
 264     return group_it->second;
 265
 266   // Default to enabled.
 267   return true;
 268 }
 269
 270 void PluginPrefs::UpdatePatternsAndNotify(std::set<base::string16>* patterns,
 271                                           const std::string& pref_name) {
 272   base::AutoLock auto_lock(lock_);
 273   ListValueToStringSet(prefs_->GetList(pref_name.c_str()), patterns);
 274
 275   NotifyPluginStatusChanged();
 276 }
 277
 278 /*static*/
 279 bool PluginPrefs::IsStringMatchedInSet(
 280     const base::string16& name,
 281     const std::set<base::string16>& pattern_set) {
 282   std::set<base::string16>::const_iterator pattern(pattern_set.begin());
 283   while (pattern != pattern_set.end()) {
 284     if (MatchPattern(name, *pattern))
 285       return true;
 286     ++pattern;
 287   }
 288
 289   return false;
 290 }
 291
 292 /* static */
 293 void PluginPrefs::ListValueToStringSet(const base::ListValue* src,
 294                                        std::set<base::string16>* dest) {
 295   DCHECK(src);
 296   DCHECK(dest);
 297   dest->clear();
 298   base::ListValue::const_iterator end(src->end());
 299   for (base::ListValue::const_iterator current(src->begin());
 300        current != end; ++current) {
 301     base::string16 plugin_name;
 302     if ((*current)->GetAsString(&plugin_name)) {
 303       dest->insert(plugin_name);
 304     }
 305   }
 306 }
 307
 308 void PluginPrefs::SetPrefs(PrefService* prefs) {
 309   prefs_ = prefs;
 310   bool update_internal_dir = false;
 311   base::FilePath last_internal_dir =
 312       prefs_->GetFilePath(prefs::kPluginsLastInternalDirectory);
 313   base::FilePath cur_internal_dir;
 314   if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &cur_internal_dir) &&
 315       cur_internal_dir != last_internal_dir) {
 316     update_internal_dir = true;
 317     prefs_->SetFilePath(
 318         prefs::kPluginsLastInternalDirectory, cur_internal_dir);
 319   }
 320
 321   bool migrate_to_pepper_flash = false;
 322 #if defined(OS_WIN) || defined(OS_MACOSX)
 323   // If bundled NPAPI Flash is enabled while Pepper Flash is disabled, we
 324   // would like to turn Pepper Flash on. And we only want to do it once.
 325   // TODO(yzshen): Remove all |migrate_to_pepper_flash|-related code after it
 326   // has been run once by most users. (Maybe Chrome 24 or Chrome 25.)
 327   // NOTE(shess): Keep in mind that Mac is on a different schedule.
 328   if (!prefs_->GetBoolean(prefs::kPluginsMigratedToPepperFlash)) {
 329     prefs_->SetBoolean(prefs::kPluginsMigratedToPepperFlash, true);
 330     migrate_to_pepper_flash = true;
 331   }
 332 #endif
 333
 334   bool remove_component_pepper_flash_settings = false;
 335   // If component-updated Pepper Flash is disabled, we would like to remove that
 336   // settings item. And we only want to do it once. (Please see the comments of
 337   // kPluginsRemovedOldComponentPepperFlashSettings for why.)
 338   // TODO(yzshen): Remove all |remove_component_pepper_flash_settings|-related
 339   // code after it has been run once by most users.
 340   if (!prefs_->GetBoolean(
 341           prefs::kPluginsRemovedOldComponentPepperFlashSettings)) {
 342     prefs_->SetBoolean(prefs::kPluginsRemovedOldComponentPepperFlashSettings,
 343                        true);
 344     remove_component_pepper_flash_settings = true;
 345   }
 346
 347   {  // Scoped update of prefs::kPluginsPluginsList.
 348     ListPrefUpdate update(prefs_, prefs::kPluginsPluginsList);
 349     base::ListValue* saved_plugins_list = update.Get();
 350     if (saved_plugins_list && !saved_plugins_list->empty()) {
 351       // The following four variables are only valid when
 352       // |migrate_to_pepper_flash| is set to true.
 353       base::FilePath npapi_flash;
 354       base::FilePath pepper_flash;
 355       base::DictionaryValue* pepper_flash_node = NULL;
 356       bool npapi_flash_enabled = false;
 357       if (migrate_to_pepper_flash) {
 358         PathService::Get(chrome::FILE_FLASH_PLUGIN, &npapi_flash);
 359         PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &pepper_flash);
 360       }
 361
 362       // Used when |remove_component_pepper_flash_settings| is set to true.
 363       base::ListValue::iterator component_pepper_flash_node =
 364           saved_plugins_list->end();
 365
 366       for (base::ListValue::iterator it = saved_plugins_list->begin();
 367            it != saved_plugins_list->end();
 368            ++it) {
 369         if (!(*it)->IsType(base::Value::TYPE_DICTIONARY)) {
 370           LOG(WARNING) << "Invalid entry in " << prefs::kPluginsPluginsList;
 371           continue;  // Oops, don't know what to do with this item.
 372         }
 373
 374         base::DictionaryValue* plugin =
 375             static_cast<base::DictionaryValue*>(*it);
 376         base::string16 group_name;
 377         bool enabled;
 378         if (!plugin->GetBoolean("enabled", &enabled))
 379           enabled = true;
 380
 381         base::FilePath::StringType path;
 382         // The plugin list constains all the plugin files in addition to the
 383         // plugin groups.
 384         if (plugin->GetString("path", &path)) {
 385           // Files have a path attribute, groups don't.
 386           base::FilePath plugin_path(path);
 387
 388           // The path to the intenral plugin directory changes everytime Chrome
 389           // is auto-updated, since it contains the current version number. For
 390           // example, it changes from foobar\Chrome\Application\21.0.1180.83 to
 391           // foobar\Chrome\Application\21.0.1180.89.
 392           // However, we would like the settings of internal plugins to persist
 393           // across Chrome updates. Therefore, we need to recognize those paths
 394           // that are within the previous internal plugin directory, and update
 395           // them in the prefs accordingly.
 396           if (update_internal_dir) {
 397             base::FilePath relative_path;
 398
 399             // Extract the part of |plugin_path| that is relative to
 400             // |last_internal_dir|. For example, |relative_path| will be
 401             // foo\bar.dll if |plugin_path| is <last_internal_dir>\foo\bar.dll.
 402             //
 403             // Every iteration the last path component from |plugin_path| is
 404             // removed and prepended to |relative_path| until we get up to
 405             // |last_internal_dir|.
 406             while (last_internal_dir.IsParent(plugin_path)) {
 407               relative_path = plugin_path.BaseName().Append(relative_path);
 408
 409               base::FilePath old_path = plugin_path;
 410               plugin_path = plugin_path.DirName();
 411               // To be extra sure that we won't end up in an infinite loop.
 412               if (old_path == plugin_path) {
 413                 NOTREACHED();
 414                 break;
 415               }
 416             }
 417
 418             // If |relative_path| is empty, |plugin_path| is not within
 419             // |last_internal_dir|. We don't need to update it.
 420             if (!relative_path.empty()) {
 421               plugin_path = cur_internal_dir.Append(relative_path);
 422               path = plugin_path.value();
 423               plugin->SetString("path", path);
 424             }
 425           }
 426
 427           if (migrate_to_pepper_flash &&
 428                      base::FilePath::CompareEqualIgnoreCase(
 429                          path, npapi_flash.value())) {
 430             npapi_flash_enabled = enabled;
 431           } else if (migrate_to_pepper_flash &&
 432                      base::FilePath::CompareEqualIgnoreCase(
 433                          path, pepper_flash.value())) {
 434             if (!enabled)
 435               pepper_flash_node = plugin;
 436           } else if (remove_component_pepper_flash_settings &&
 437                      IsComponentUpdatedPepperFlash(plugin_path)) {
 438             if (!enabled) {
 439               component_pepper_flash_node = it;
 440               // Skip setting |enabled| into |plugin_state_|.
 441               continue;
 442             }
 443           }
 444
 445           plugin_state_.Set(plugin_path, enabled);
 446         } else if (!enabled && plugin->GetString("name", &group_name)) {
 447           // Otherwise this is a list of groups.
 448           plugin_group_state_[group_name] = false;
 449         }
 450       }
 451
 452       if (npapi_flash_enabled && pepper_flash_node) {
 453         DCHECK(migrate_to_pepper_flash);
 454         pepper_flash_node->SetBoolean("enabled", true);
 455         plugin_state_.Set(pepper_flash, true);
 456       }
 457
 458       if (component_pepper_flash_node != saved_plugins_list->end()) {
 459         DCHECK(remove_component_pepper_flash_settings);
 460         saved_plugins_list->Erase(component_pepper_flash_node, NULL);
 461       }
 462     } else {
 463       // If the saved plugin list is empty, then the call to UpdatePreferences()
 464       // below failed in an earlier run, possibly because the user closed the
 465       // browser too quickly.
 466
 467       // Only want one PDF plugin enabled at a time. See http://crbug.com/50105
 468       // for background.
 469       plugin_group_state_[base::ASCIIToUTF16(
 470           PluginMetadata::kAdobeReaderGroupName)] = false;
 471     }
 472   }  // Scoped update of prefs::kPluginsPluginsList.
 473
 474   // Build the set of policy enabled/disabled plugin patterns once and cache it.
 475   // Don't do this in the constructor, there's no profile available there.
 476   ListValueToStringSet(prefs_->GetList(prefs::kPluginsDisabledPlugins),
 477                        &policy_disabled_plugin_patterns_);
 478   ListValueToStringSet(
 479       prefs_->GetList(prefs::kPluginsDisabledPluginsExceptions),
 480       &policy_disabled_plugin_exception_patterns_);
 481   ListValueToStringSet(prefs_->GetList(prefs::kPluginsEnabledPlugins),
 482                        &policy_enabled_plugin_patterns_);
 483
 484   registrar_.Init(prefs_);
 485
 486   // Because pointers to our own members will remain unchanged for the
 487   // lifetime of |registrar_| (which we also own), we can bind their
 488   // pointer values directly in the callbacks to avoid string-based
 489   // lookups at notification time.
 490   registrar_.Add(prefs::kPluginsDisabledPlugins,
 491                  base::Bind(&PluginPrefs::UpdatePatternsAndNotify,
 492                             base::Unretained(this),
 493                             &policy_disabled_plugin_patterns_));
 494   registrar_.Add(prefs::kPluginsDisabledPluginsExceptions,
 495                  base::Bind(&PluginPrefs::UpdatePatternsAndNotify,
 496                             base::Unretained(this),
 497                             &policy_disabled_plugin_exception_patterns_));
 498   registrar_.Add(prefs::kPluginsEnabledPlugins,
 499                  base::Bind(&PluginPrefs::UpdatePatternsAndNotify,
 500                             base::Unretained(this),
 501                             &policy_enabled_plugin_patterns_));
 502
 503   NotifyPluginStatusChanged();
 504 }
 505
 506 void PluginPrefs::ShutdownOnUIThread() {
 507   prefs_ = NULL;
 508   registrar_.RemoveAll();
 509 }
 510
 511 PluginPrefs::PluginPrefs() : profile_(NULL),
 512                              prefs_(NULL) {
 513 }
 514
 515 PluginPrefs::~PluginPrefs() {
 516 }
 517
 518 void PluginPrefs::SetPolicyEnforcedPluginPatterns(
 519     const std::set<base::string16>& disabled_patterns,
 520     const std::set<base::string16>& disabled_exception_patterns,
 521     const std::set<base::string16>& enabled_patterns) {
 522   policy_disabled_plugin_patterns_ = disabled_patterns;
 523   policy_disabled_plugin_exception_patterns_ = disabled_exception_patterns;
 524   policy_enabled_plugin_patterns_ = enabled_patterns;
 525 }
 526
 527 void PluginPrefs::OnUpdatePreferences(
 528     const std::vector<content::WebPluginInfo>& plugins) {
 529   if (!prefs_)
 530     return;
 531
 532   PluginFinder* finder = PluginFinder::GetInstance();
 533   ListPrefUpdate update(prefs_, prefs::kPluginsPluginsList);
 534   base::ListValue* plugins_list = update.Get();
 535   plugins_list->Clear();
 536
 537   base::FilePath internal_dir;
 538   if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &internal_dir))
 539     prefs_->SetFilePath(prefs::kPluginsLastInternalDirectory, internal_dir);
 540
 541   base::AutoLock auto_lock(lock_);
 542
 543   // Add the plugin files.
 544   std::set<base::string16> group_names;
 545   for (size_t i = 0; i < plugins.size(); ++i) {
 546     base::DictionaryValue* summary = new base::DictionaryValue();
 547     summary->SetString("path", plugins[i].path.value());
 548     summary->SetString("name", plugins[i].name);
 549     summary->SetString("version", plugins[i].version);
 550     bool enabled = true;
 551     plugin_state_.Get(plugins[i].path, &enabled);
 552     summary->SetBoolean("enabled", enabled);
 553     plugins_list->Append(summary);
 554
 555     scoped_ptr<PluginMetadata> plugin_metadata(
 556         finder->GetPluginMetadata(plugins[i]));
 557     // Insert into a set of all group names.
 558     group_names.insert(plugin_metadata->name());
 559   }
 560
 561   // Add the plug-in groups.
 562   for (std::set<base::string16>::const_iterator it = group_names.begin();
 563       it != group_names.end(); ++it) {
 564     base::DictionaryValue* summary = new base::DictionaryValue();
 565     summary->SetString("name", *it);
 566     bool enabled = true;
 567     std::map<base::string16, bool>::iterator gstate_it =
 568         plugin_group_state_.find(*it);
 569     if (gstate_it != plugin_group_state_.end())
 570       enabled = gstate_it->second;
 571     summary->SetBoolean("enabled", enabled);
 572     plugins_list->Append(summary);
 573   }
 574 }
 575
 576 void PluginPrefs::NotifyPluginStatusChanged() {
 577   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 578   content::NotificationService::current()->Notify(
 579       chrome::NOTIFICATION_PLUGIN_ENABLE_STATUS_CHANGED,
 580       content::Source<Profile>(profile_),
 581       content::NotificationService::NoDetails());
 582 }