Allow extension APIs to be restricted to a subset of Chrome channels using the

chrome/common/extensions/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/feature.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
 #include "chrome/common/chrome_switches.h"
 
+using chrome::VersionInfo;
+
 namespace {
 
 struct Mappings {
   Mappings() {
     extension_types["extension"] = Extension::TYPE_EXTENSION;
     extension_types["theme"] = Extension::TYPE_THEME;
     extension_types["packaged_app"] = Extension::TYPE_PACKAGED_APP;
     extension_types["hosted_app"] = Extension::TYPE_HOSTED_APP;
     extension_types["platform_app"] = Extension::TYPE_PLATFORM_APP;
 
     contexts["blessed_extension"] =
         extensions::Feature::BLESSED_EXTENSION_CONTEXT;
     contexts["unblessed_extension"] =
         extensions::Feature::UNBLESSED_EXTENSION_CONTEXT;
     contexts["content_script"] = extensions::Feature::CONTENT_SCRIPT_CONTEXT;
     contexts["web_page"] = extensions::Feature::WEB_PAGE_CONTEXT;
 
     locations["component"] = extensions::Feature::COMPONENT_LOCATION;
 
     platforms["chromeos"] = extensions::Feature::CHROMEOS_PLATFORM;
+
+    channels["trunk"] = VersionInfo::CHANNEL_UNKNOWN;
+    channels["canary"] = VersionInfo::CHANNEL_CANARY;
+    channels["dev"] = VersionInfo::CHANNEL_DEV;
+    channels["beta"] = VersionInfo::CHANNEL_BETA;
+    channels["stable"] = VersionInfo::CHANNEL_STABLE;
   }
 
   std::map<std::string, Extension::Type> extension_types;
   std::map<std::string, extensions::Feature::Context> contexts;
   std::map<std::string, extensions::Feature::Location> locations;
   std::map<std::string, extensions::Feature::Platform> platforms;
+  std::map<std::string, VersionInfo::Channel> channels;
 };
 
-static base::LazyInstance<Mappings> g_mappings =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<Mappings> g_mappings = LAZY_INSTANCE_INITIALIZER;
+
+struct Channel {
+  Channel() : channel(chrome::VersionInfo::GetChannel()) {}
+
+  chrome::VersionInfo::Channel channel;
+};
+
+static base::LazyInstance<Channel> g_channel = LAZY_INSTANCE_INITIALIZER;
 
 // 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) {
   ListValue* list_value = NULL;
   if (!value->GetList(property, &list_value))
     return;
 
@@ skipping 59 matching lines @@
 }
 
 }  // namespace
 
 namespace extensions {
 
 Feature::Feature()
   : location_(UNSPECIFIED_LOCATION),
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
-    max_manifest_version_(0) {
+    max_manifest_version_(0),
+    supported_channel_(VersionInfo::CHANNEL_UNKNOWN) {
 }
 
 Feature::Feature(const Feature& 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_) {
+      max_manifest_version_(other.max_manifest_version_),
+      supported_channel_(other.supported_channel_) {
 }
 
 Feature::~Feature() {
 }
 
 bool Feature::Equals(const Feature& 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_;
+      max_manifest_version_ == other.max_manifest_version_ &&
+      supported_channel_ == other.supported_channel_;
 }
 
 // static
 Feature::Platform Feature::GetCurrentPlatform() {
 #if defined(OS_CHROMEOS)
   return CHROMEOS_PLATFORM;
 #else
   return UNSPECIFIED_PLATFORM;
 #endif
 }
@@ skipping 11 matching lines @@
   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, "supported_channel", &supported_channel_,
+      g_mappings.Get().channels);
 }
 
 std::string Feature::GetErrorMessage(Feature::Availability result) {
   switch (result) {
     case IS_AVAILABLE:
       return "";
     case NOT_FOUND_IN_WHITELIST:
       return "Not allowed for specified extension ID.";
     case INVALID_TYPE:
       return "Not allowed for specified package type (theme, app, etc.).";
     case INVALID_CONTEXT:
       return "Not allowed for specified context type content script, extension "
           "page, web page, etc.).";
     case INVALID_LOCATION:
       return "Not allowed for specified install location.";
     case INVALID_PLATFORM:
       return "Not allowed for specified platform.";
     case INVALID_MIN_MANIFEST_VERSION:
       return base::StringPrintf("Requires manifest version of at least %d.",
                                 min_manifest_version_);
     case INVALID_MAX_MANIFEST_VERSION:
       return base::StringPrintf("Requires manifest version of %d or lower.",
                                 max_manifest_version_);
-    default:
-      CHECK(false);
-      return "";
+    case NOT_PRESENT:
+      return "Requires a different Feature that is not present.";
+    case UNSUPPORTED_CHANNEL:
+      return base::StringPrintf("Channel %d is unsupported.",
+                                supported_channel_);
   }
+
+  return "";
 }
 
 Feature::Availability Feature::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)
@@ skipping 25 matching lines @@
 
   if (platform_ != UNSPECIFIED_PLATFORM && platform_ != platform)
     return INVALID_PLATFORM;
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return INVALID_MIN_MANIFEST_VERSION;
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
     return INVALID_MAX_MANIFEST_VERSION;
 
+  if (supported_channel_ < g_channel.Get().channel)
+    return UNSUPPORTED_CHANNEL;
+
   return IS_AVAILABLE;
 }
 
 Feature::Availability Feature::IsAvailableToContext(
     const Extension* extension,
     Feature::Context context,
     Feature::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 INVALID_CONTEXT;
   }
 
   return IS_AVAILABLE;
 }
 
+// static
+void Feature::SetChannelForTesting(VersionInfo::Channel channel) {
+  g_channel.Get().channel = channel;
+}
+
 }  // namespace