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