[Extensions] Move Feature channel code into //extensions

extensions/common/features/simple_feature.cc

 // Copyright 2014 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 "extensions/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "components/crx_file/id_util.h"
 #include "extensions/common/extension_api.h"
+#include "extensions/common/features/feature_channel.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/features/feature_util.h"
 #include "extensions/common/switches.h"
 
 using crx_file::id_util::HashedIdInHex;
 
 namespace extensions {
 
 namespace {
 
@@ skipping 42 matching lines @@
 template<typename T>
 void ParseEnum(const std::string& string_value,
                T* enum_value,
                const std::map<std::string, T>& mapping) {
   const auto& iter = mapping.find(string_value);
   if (iter == mapping.end())
     CRASH_WITH_MINIDUMP("Enum value not found: " + string_value);
   *enum_value = iter->second;
 }
 
-template<typename T>
-void ParseEnum(const base::DictionaryValue* value,
-               const std::string& property,
+template <typename T>
+void ParseEnum(const base::Value* value,
                T* enum_value,
                const std::map<std::string, T>& mapping) {
   std::string string_value;
-  if (!value->GetString(property, &string_value))
+  if (!value->GetAsString(&string_value))
     return;
 
   ParseEnum(string_value, enum_value, mapping);
 }
 
 template<typename T>
 void ParseEnumVector(const base::Value* value,
                      std::vector<T>* enum_vector,
                      const std::map<std::string, T>& mapping) {
   enum_vector->clear();
@@ skipping 82 matching lines @@
       return "hosted app";
     case Feature::WEBUI_CONTEXT:
       return "webui";
     case Feature::SERVICE_WORKER_CONTEXT:
       return "service worker";
   }
   NOTREACHED();
   return "";
 }
 
+std::string GetDisplayName(version_info::Channel channel) {
+  switch (channel) {
+    case version_info::Channel::UNKNOWN:
+      return "trunk";
+    case version_info::Channel::CANARY:
+      return "canary";
+    case version_info::Channel::DEV:
+      return "dev";
+    case version_info::Channel::BETA:
+      return "beta";
+    case version_info::Channel::STABLE:
+      return "stable";
+  }
+  NOTREACHED();
+  return "";
+}
+
 // Gets a human-readable list of the display names (pluralized, comma separated
 // with the "and" in the correct place) for each of |enum_types|.
 template <typename EnumType>
 std::string ListDisplayNames(const std::vector<EnumType>& enum_types) {
   std::string display_name_list;
   for (size_t i = 0; i < enum_types.size(); ++i) {
     // Pluralize type name.
     display_name_list += GetDisplayName(enum_types[i]) + "s";
     // Comma-separate entries, with an Oxford comma if there is more than 2
     // total entries.
@@ skipping 64 matching lines @@
 
     locations["component"] = SimpleFeature::COMPONENT_LOCATION;
     locations["external_component"] =
         SimpleFeature::EXTERNAL_COMPONENT_LOCATION;
     locations["policy"] = SimpleFeature::POLICY_LOCATION;
 
     platforms["chromeos"] = Feature::CHROMEOS_PLATFORM;
     platforms["linux"] = Feature::LINUX_PLATFORM;
     platforms["mac"] = Feature::MACOSX_PLATFORM;
     platforms["win"] = Feature::WIN_PLATFORM;
+
+    channels["trunk"] = version_info::Channel::UNKNOWN;
+    channels["canary"] = version_info::Channel::CANARY;
+    channels["dev"] = version_info::Channel::DEV;
+    channels["beta"] = version_info::Channel::BETA;
+    channels["stable"] = version_info::Channel::STABLE;
   }
 
   std::map<std::string, Manifest::Type> extension_types;
   std::map<std::string, Feature::Context> contexts;
   std::map<std::string, SimpleFeature::Location> locations;
   std::map<std::string, Feature::Platform> platforms;
+  std::map<std::string, version_info::Channel> channels;
 };
 
 SimpleFeature::SimpleFeature()
     : location_(UNSPECIFIED_LOCATION),
       min_manifest_version_(0),
       max_manifest_version_(0),
       component_extensions_auto_granted_(true) {}
 
 SimpleFeature::~SimpleFeature() {}
 
-bool SimpleFeature::HasDependencies() const {
-  return !dependencies_.empty();
-}
-
-void SimpleFeature::AddFilter(std::unique_ptr<SimpleFeatureFilter> filter) {
-  filters_.push_back(std::move(filter));
-}
-
 std::string SimpleFeature::Parse(const base::DictionaryValue* dictionary) {
   static base::LazyInstance<SimpleFeature::Mappings> mappings =
       LAZY_INSTANCE_INITIALIZER;
 
   no_parent_ = false;
   for (base::DictionaryValue::Iterator it(*dictionary);
       !it.IsAtEnd();
       it.Advance()) {
     const std::string& key = it.key();
     const base::Value* value = &it.value();
     if (key == "matches") {
       ParseURLPatterns(dictionary, "matches", &matches_);
     } else if (key == "blacklist") {
       ParseVector(value, &blacklist_);
     } else if (key == "whitelist") {
       ParseVector(value, &whitelist_);
     } else if (key == "dependencies") {
       ParseVector(value, &dependencies_);
     } else if (key == "extension_types") {
       ParseEnumVector<Manifest::Type>(value, &extension_types_,
                                       mappings.Get().extension_types);
     } else if (key == "contexts") {
       ParseEnumVector<Context>(value, &contexts_,
                                mappings.Get().contexts);
     } else if (key == "location") {
-      ParseEnum<Location>(dictionary, "location", &location_,
-                          mappings.Get().locations);
+      ParseEnum<Location>(value, &location_, mappings.Get().locations);
     } else if (key == "platforms") {
       ParseEnumVector<Platform>(value, &platforms_,
                                 mappings.Get().platforms);
     } else if (key == "min_manifest_version") {
       dictionary->GetInteger("min_manifest_version", &min_manifest_version_);
     } else if (key == "max_manifest_version") {
       dictionary->GetInteger("max_manifest_version", &max_manifest_version_);
     } else if (key == "noparent") {
       dictionary->GetBoolean("noparent", &no_parent_);
     } else if (key == "component_extensions_auto_granted") {
       dictionary->GetBoolean("component_extensions_auto_granted",
                              &component_extensions_auto_granted_);
     } else if (key == "command_line_switch") {
       dictionary->GetString("command_line_switch", &command_line_switch_);
+    } else if (key == "channel") {
+      channel_.reset(new version_info::Channel(version_info::Channel::UNKNOWN));
+      ParseEnum<version_info::Channel>(value, channel_.get(),
+                                       mappings.Get().channels);
     }
   }
 
   // NOTE: ideally we'd sanity check that "matches" can be specified if and
   // only if there's a "web_page" or "webui" context, but without
   // (Simple)Features being aware of their own heirarchy this is impossible.
   //
   // For example, we might have feature "foo" available to "web_page" context
   // and "matches" google.com/*. Then a sub-feature "foo.bar" might override
   // "matches" to be chromium.org/*. That sub-feature doesn't need to specify
   // "web_page" context because it's inherited, but we don't know that here.
 
-  std::string result;
-  for (const auto& filter : filters_) {
-    result = filter->Parse(dictionary);
-    if (!result.empty())
-      break;
-  }
+  // All features must be channel-restricted, either directly or through
+  // dependents.
+  if (!channel_ && dependencies_.empty())
+    return name() + ": Must supply a value for channel or dependencies.";
 
-  return result;
+  return std::string();
 }
 
 Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
     Manifest::Type type,
     Manifest::Location location,
     int manifest_version,
     Platform platform) const {
   // Check extension type first to avoid granting platform app permissions
   // to component extensions.
@@ skipping 31 matching lines @@
     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 (!command_line_switch_.empty() &&
       !IsCommandLineSwitchEnabled(command_line_switch_)) {
     return CreateAvailability(MISSING_COMMAND_LINE_SWITCH, type);
   }
 
-  for (const auto& filter : filters_) {
-    Availability availability = filter->IsAvailableToManifest(
-        extension_id, type, location, manifest_version, platform);
-    if (!availability.is_available())
-      return availability;
-  }
+  if (channel_ && check_channel_ && *channel_ < GetCurrentChannel())
+    return CreateAvailability(UNSUPPORTED_CHANNEL, *channel_);
 
   return CheckDependencies(base::Bind(&IsAvailableToManifestForBind,
                                       extension_id,
                                       type,
                                       location,
                                       manifest_version,
                                       platform));
 }
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
@@ skipping 19 matching lines @@
     return CreateAvailability(INVALID_CONTEXT, context);
 
   // TODO(kalman): Consider checking |matches_| regardless of context type.
   // Fewer surprises, and if the feature configuration wants to isolate
   // "matches" from say "blessed_extension" then they can use complex features.
   if ((context == WEB_PAGE_CONTEXT || context == WEBUI_CONTEXT) &&
       !matches_.MatchesURL(url)) {
     return CreateAvailability(INVALID_URL, url);
   }
 
-  for (const auto& filter : filters_) {
-    Availability availability =
-        filter->IsAvailableToContext(extension, context, url, platform);
-    if (!availability.is_available())
-      return availability;
-  }
-
   // TODO(kalman): Assert that if the context was a webpage or WebUI context
   // then at some point a "matches" restriction was checked.
   return CheckDependencies(base::Bind(
       &IsAvailableToContextForBind, extension, context, url, platform));
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
     AvailabilityResult result,
     Manifest::Type type,
     const GURL& url,
-    Context context) const {
+    Context context,
+    version_info::Channel channel) const {
   switch (result) {
     case IS_AVAILABLE:
       return std::string();
     case NOT_FOUND_IN_WHITELIST:
     case FOUND_IN_BLACKLIST:
       return base::StringPrintf(
           "'%s' is not allowed for specified extension ID.",
           name().c_str());
     case INVALID_URL:
       return base::StringPrintf("'%s' is not allowed on %s.",
@@ skipping 29 matching lines @@
       return base::StringPrintf(
           "'%s' requires manifest version of %d or lower.",
           name().c_str(),
           max_manifest_version_);
     case NOT_PRESENT:
       return base::StringPrintf(
           "'%s' requires a different Feature that is not present.",
           name().c_str());
     case UNSUPPORTED_CHANNEL:
       return base::StringPrintf(
-          "'%s' is unsupported in this version of the platform.",
-          name().c_str());
+          "'%s' requires %s channel or newer, but this is the %s channel.",
+          name().c_str(), GetDisplayName(channel).c_str(),
+          GetDisplayName(GetCurrentChannel()).c_str());
     case MISSING_COMMAND_LINE_SWITCH:
       return base::StringPrintf(
           "'%s' requires the '%s' command line switch to be enabled.",
           name().c_str(), command_line_switch_.c_str());
   }
 
   NOTREACHED();
   return std::string();
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
-                                     UNSPECIFIED_CONTEXT));
+                                     UNSPECIFIED_CONTEXT,
+                                     version_info::Channel::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result, Manifest::Type type) const {
-  return Availability(result, GetAvailabilityMessage(result, type, GURL(),
-                                                     UNSPECIFIED_CONTEXT));
+  return Availability(
+      result, GetAvailabilityMessage(result, type, GURL(), UNSPECIFIED_CONTEXT,
+                                     version_info::Channel::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result,
     const GURL& url) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, url,
-                                     UNSPECIFIED_CONTEXT));
+                                     UNSPECIFIED_CONTEXT,
+                                     version_info::Channel::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result,
     Context context) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
-                                     context));
+                                     context, version_info::Channel::UNKNOWN));
+}
+
+Feature::Availability SimpleFeature::CreateAvailability(
+    AvailabilityResult result,
+    version_info::Channel channel) const {
+  return Availability(
+      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
+                                     UNSPECIFIED_CONTEXT, channel));
 }
 
 bool SimpleFeature::IsInternal() const {
   return false;
 }
 
 bool SimpleFeature::IsIdInBlacklist(const std::string& extension_id) const {
   return IsIdInList(extension_id, blacklist_);
 }
 
@@ skipping 60 matching lines @@
 bool SimpleFeature::IsValidExtensionId(const std::string& extension_id) {
   // Belt-and-suspenders philosophy here. We should be pretty confident by this
   // point that we've validated the extension ID format, but in case something
   // slips through, we avoid a class of attack where creative ID manipulation
   // leads to hash collisions.
   // 128 bits / 4 = 32 mpdecimal characters
   return (extension_id.length() == 32);
 }
 
 }  // namespace extensions