Put some plug-ins behind an infobar, where they have:...

webkit/plugins/npapi/plugin_group.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 "webkit/plugins/npapi/plugin_group.h"
 
 #include "base/linked_ptr.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/npapi/webplugininfo.h"
 
 namespace webkit {
 namespace npapi {
 
 const char* PluginGroup::kAdobeReaderGroupName = "Adobe Reader";
 const char* PluginGroup::kAdobeReaderUpdateURL = "http://get.adobe.com/reader/";
+const char* PluginGroup::kJavaGroupName = "Java";
+const char* PluginGroup::kQuickTimeGroupName = "QuickTime";
+const char* PluginGroup::kShockwaveGroupName = "Shockwave";
 
 /*static*/
 std::set<string16>* PluginGroup::policy_disabled_plugin_patterns_;
 
 /*static*/
 void PluginGroup::SetPolicyDisabledPluginPatterns(
     const std::set<string16>& set) {
   if (!policy_disabled_plugin_patterns_)
     policy_disabled_plugin_patterns_ = new std::set<string16>(set);
   else
@@ skipping 12 matching lines @@
       return true;
     ++pattern;
   }
 
   return false;
 }
 
 VersionRange::VersionRange(VersionRangeDefinition definition)
     : low_str(definition.version_matcher_low),
       high_str(definition.version_matcher_high),
-      min_str(definition.min_version) {
+      min_str(definition.min_version),
+      requires_authorization(definition.requires_authorization) {
   if (!low_str.empty())
     low.reset(Version::GetVersionFromString(low_str));
   if (!high_str.empty())
     high.reset(Version::GetVersionFromString(high_str));
   if (!min_str.empty())
     min.reset(Version::GetVersionFromString(min_str));
 }
 
 VersionRange::VersionRange(const VersionRange& other) {
   InitFrom(other);
 }
 
 VersionRange& VersionRange::operator=(const VersionRange& other) {
   InitFrom(other);
   return *this;
 }
 
 VersionRange::~VersionRange() {}
 
 void VersionRange::InitFrom(const VersionRange& other) {
   low_str = other.low_str;
   high_str = other.high_str;
   min_str = other.min_str;
   low.reset(Version::GetVersionFromString(other.low_str));
   high.reset(Version::GetVersionFromString(other.high_str));
   min.reset(Version::GetVersionFromString(other.min_str));
+  requires_authorization = other.requires_authorization;
 }
 
 PluginGroup::PluginGroup(const string16& group_name,
                          const string16& name_matcher,
                          const std::string& update_url,
                          const std::string& identifier)
     : identifier_(identifier),
       group_name_(group_name),
       name_matcher_(name_matcher),
       update_url_(update_url),
@@ skipping 304 matching lines @@
 
 // Returns true if the latest version of this plugin group is vulnerable.
 bool PluginGroup::IsVulnerable() const {
   for (size_t i = 0; i < version_ranges_.size(); ++i) {
     if (IsPluginOutdated(*version_, version_ranges_[i]))
       return true;
   }
   return false;
 }
 
+bool PluginGroup::RequiresAuthorization() const {
+  for (size_t i = 0; i < version_ranges_.size(); ++i) {
+    if (IsVersionInRange(*version_, version_ranges_[i]) &&
+        version_ranges_[i].requires_authorization)
+      return true;
+  }
+  return false;
+}
+
 bool PluginGroup::IsEmpty() const {
   return web_plugin_infos_.size() == 0;
 }
 
 void PluginGroup::DisableOutdatedPlugins() {
   bool first_enabled = true;
 
   for (size_t i = 0; i < web_plugin_infos_.size(); ++i) {
     scoped_ptr<Version> version(
         CreateVersionFromString(web_plugin_infos_[i].version));
@@ skipping 107 matching lines @@
     // Only changeable if not managed.
     if (plugin->enabled & WebPluginInfo::MANAGED_MASK)
       return false;
     plugin->enabled = new_reason;
   }
   return true;
 }
 
 }  // namespace npapi
 }  // namespace webkit