Implement ComplexFeature to support permission features with multiple rules.

chrome/common/extensions/features/simple_feature.cc

 // Copyright (c) 2012 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/common/extensions/features/feature.h"
+#include "chrome/common/extensions/features/simple_feature.h"
 
 #include <map>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "base/string_util.h"
 #include "chrome/common/chrome_switches.h"
 
 using chrome::VersionInfo;
 using extensions::Extension;
 
 namespace {
 
 struct Mappings {
   Mappings() {
     extension_types["extension"] = Extension::TYPE_EXTENSION;
@@ skipping 34 matching lines @@
   typedef std::map<std::string, VersionInfo::Channel> ChannelsMap;
   ChannelsMap channels = g_mappings.Get().channels;
   for (ChannelsMap::iterator i = channels.begin(); i != channels.end(); ++i) {
     if (i->second == channel)
       return i->first;
   }
   NOTREACHED();
   return "unknown";
 }
 
-const VersionInfo::Channel kDefaultChannel = VersionInfo::CHANNEL_STABLE;
-VersionInfo::Channel g_current_channel = kDefaultChannel;
-
 // TODO(aa): Can we replace all this manual parsing with JSON schema stuff?
 
 void ParseSet(const DictionaryValue* value,
               const std::string& property,
               std::set<std::string>* set) {
   const ListValue* list_value = NULL;
   if (!value->GetList(property, &list_value))
     return;
 
   set->clear();
@@ skipping 77 matching lines @@
   }
 
   NOTREACHED();
   return "";
 }
 
 }  // namespace
 
 namespace extensions {
 
-Feature::Feature()
+SimpleFeature::SimpleFeature()
   : location_(UNSPECIFIED_LOCATION),
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
     max_manifest_version_(0),
     channel_(VersionInfo::CHANNEL_UNKNOWN) {
 }
 
-Feature::Feature(const Feature& other)
+SimpleFeature::SimpleFeature(const SimpleFeature& other)
     : whitelist_(other.whitelist_),
       extension_types_(other.extension_types_),
       contexts_(other.contexts_),
       location_(other.location_),
       platform_(other.platform_),
       min_manifest_version_(other.min_manifest_version_),
       max_manifest_version_(other.max_manifest_version_),
       channel_(other.channel_) {
 }
 
-Feature::~Feature() {
+SimpleFeature::~SimpleFeature() {
 }
 
-bool Feature::Equals(const Feature& other) const {
+bool SimpleFeature::Equals(const SimpleFeature& other) const {
   return whitelist_ == other.whitelist_ &&
       extension_types_ == other.extension_types_ &&
       contexts_ == other.contexts_ &&
       location_ == other.location_ &&
       platform_ == other.platform_ &&
       min_manifest_version_ == other.min_manifest_version_ &&
       max_manifest_version_ == other.max_manifest_version_ &&
       channel_ == other.channel_;
 }
 
-// static
-Feature::Platform Feature::GetCurrentPlatform() {
-#if defined(OS_CHROMEOS)
-  return CHROMEOS_PLATFORM;
-#else
-  return UNSPECIFIED_PLATFORM;
-#endif
-}
-
-// static
-Feature::Location Feature::ConvertLocation(Extension::Location location) {
-  if (location == Extension::COMPONENT)
-    return COMPONENT_LOCATION;
-  else
-    return UNSPECIFIED_LOCATION;
-}
-
-void Feature::Parse(const DictionaryValue* value) {
+void SimpleFeature::Parse(const DictionaryValue* value) {
   ParseSet(value, "whitelist", &whitelist_);
   ParseEnumSet<Extension::Type>(value, "extension_types", &extension_types_,
                                 g_mappings.Get().extension_types);
   ParseEnumSet<Context>(value, "contexts", &contexts_,
                         g_mappings.Get().contexts);
   ParseEnum<Location>(value, "location", &location_,
                       g_mappings.Get().locations);
   ParseEnum<Platform>(value, "platform", &platform_,
                       g_mappings.Get().platforms);
   value->GetInteger("min_manifest_version", &min_manifest_version_);
   value->GetInteger("max_manifest_version", &max_manifest_version_);
   ParseEnum<VersionInfo::Channel>(
       value, "channel", &channel_,
       g_mappings.Get().channels);
 }
 
-Feature::Availability Feature::IsAvailableToManifest(
+Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
     Extension::Type type,
     Location location,
     int manifest_version,
     Platform platform) const {
   // Component extensions can access any feature.
   if (location == COMPONENT_LOCATION)
     return CreateAvailability(IS_AVAILABLE, type);
 
   if (!whitelist_.empty()) {
@@ skipping 22 matching lines @@
 
   if (platform_ != UNSPECIFIED_PLATFORM && platform_ != platform)
     return CreateAvailability(INVALID_PLATFORM, type);
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return CreateAvailability(INVALID_MIN_MANIFEST_VERSION, type);
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
     return CreateAvailability(INVALID_MAX_MANIFEST_VERSION, type);
 
-  if (channel_ < g_current_channel)
+  if (channel_ <  Feature::GetCurrentChannel())
     return CreateAvailability(UNSUPPORTED_CHANNEL, type);
 
   return CreateAvailability(IS_AVAILABLE, type);
 }
 
-Feature::Availability Feature::IsAvailableToContext(
+Feature::Availability SimpleFeature::IsAvailableToContext(
     const Extension* extension,
-    Feature::Context context,
-    Feature::Platform platform) const {
+    SimpleFeature::Context context,
+    SimpleFeature::Platform platform) const {
   Availability result = IsAvailableToManifest(
       extension->id(),
       extension->GetType(),
       ConvertLocation(extension->location()),
       extension->manifest_version(),
       platform);
   if (!result.is_available())
     return result;
 
   if (!contexts_.empty() &&
       contexts_.find(context) == contexts_.end()) {
     return CreateAvailability(INVALID_CONTEXT, extension->GetType());
   }
 
   return CreateAvailability(IS_AVAILABLE);
 }
 
-// static
-chrome::VersionInfo::Channel Feature::GetCurrentChannel() {
-  return g_current_channel;
-}
-
-// static
-void Feature::SetCurrentChannel(VersionInfo::Channel channel) {
-  g_current_channel = channel;
-}
-
-// static
-chrome::VersionInfo::Channel Feature::GetDefaultChannel() {
-  return kDefaultChannel;
-}
-
-Feature::Availability Feature::CreateAvailability(
-    AvailabilityResult result) const {
-  return Availability(
-      result, GetAvailabilityMessage(result, Extension::TYPE_UNKNOWN));
-}
-
-Feature::Availability Feature::CreateAvailability(
-    AvailabilityResult result, Extension::Type type) const {
-  return Availability(result, GetAvailabilityMessage(result, type));
-}
-
-std::string Feature::GetAvailabilityMessage(
+std::string SimpleFeature::GetAvailabilityMessage(
     AvailabilityResult result, Extension::Type type) const {
   switch (result) {
     case IS_AVAILABLE:
       return "";
     case NOT_FOUND_IN_WHITELIST:
       return base::StringPrintf(
           "'%s' is not allowed for specified extension ID.",
           name().c_str());
     case INVALID_TYPE: {
       std::string allowed_type_names;
@@ skipping 50 matching lines @@
               "%s channel.",
           name().c_str(),
           GetChannelName(channel_).c_str(),
           GetChannelName(GetCurrentChannel()).c_str());
   }
 
   NOTREACHED();
   return "";
 }
 
+Feature::Availability SimpleFeature::CreateAvailability(
+    AvailabilityResult result) const {
+  return Availability(
+      result, GetAvailabilityMessage(result, Extension::TYPE_UNKNOWN));
+}
+
+Feature::Availability SimpleFeature::CreateAvailability(
+    AvailabilityResult result, Extension::Type type) const {
+  return Availability(result, GetAvailabilityMessage(result, type));
+}
+
+std::set<Feature::Context>* SimpleFeature::GetContexts() {
+  return &contexts_;
+}
 
 }  // namespace extensions