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

chrome/common/extensions/feature_unittest.cc

Index: chrome/common/extensions/feature_unittest.cc
diff --git a/chrome/common/extensions/feature_unittest.cc b/chrome/common/extensions/feature_unittest.cc
index c4cc1a3addafdc3c74a463b28097f5ed825450ef..7170fcf9899e07ebafd8d5e091e71478d3668cff 100644
--- a/chrome/common/extensions/feature_unittest.cc
+++ b/chrome/common/extensions/feature_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 
+using chrome::VersionInfo;
 using extensions::Feature;
 
 namespace {
@@ -19,8 +20,6 @@ struct IsAvailableTestData {
   Feature::Availability expected_result;
 };
 
-}  // namespace
-
 TEST(ExtensionFeatureTest, IsAvailableNullCase) {
   const IsAvailableTestData tests[] = {
     { "", Extension::TYPE_UNKNOWN,
@@ -415,3 +414,97 @@ TEST(ExtensionFeatureTest, Equals) {
   feature2.set_max_manifest_version(0);
   EXPECT_FALSE(feature2.Equals(feature));
 }
+
+Feature::Availability IsAvailableInChannel(
+    const std::string& supported_channel, VersionInfo::Channel channel) {
+  Feature feature;
+  feature.SetChannelForTesting(channel);
+
+  if (!supported_channel.empty()) {
+    DictionaryValue feature_value;
+    feature_value.SetString("supported_channel", supported_channel);
+    feature.Parse(&feature_value);
+  }
+
+  return feature.IsAvailableToManifest(
+      "random-extension",
+      Extension::TYPE_UNKNOWN,
+      Feature::UNSPECIFIED_LOCATION,
+      -1);
+}
+
+TEST(ExtensionFeatureTest, SupportedChannel) {
+  // Default supported channel (stable).

[Aaron Boodman, 2012/04/11 23:35:53]

I thought the default was going to be trunk.

[not at google - send to devlin, 2012/04/12 00:05:21]

Mm, we went back and forth, I can't remember. Yeah you're right, we did.

but then I got lazy and made it stable, because that'd require updating a whole
bunch of json files.

This is me justifying my laziness, but this the way it works now and it seems ok
to leave it that way.

Further justification of laziness: in a way it's also consistent with
experimental APIs, you need to explicitly mark something as experimental to make
it experimental.  It's stable by default.

+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("", VersionInfo::CHANNEL_UNKNOWN));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("", VersionInfo::CHANNEL_CANARY));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("", VersionInfo::CHANNEL_DEV));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("", VersionInfo::CHANNEL_BETA));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("", VersionInfo::CHANNEL_STABLE));
+
+  // stable supported.
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("stable", VersionInfo::CHANNEL_UNKNOWN));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("stable", VersionInfo::CHANNEL_CANARY));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("stable", VersionInfo::CHANNEL_DEV));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("stable", VersionInfo::CHANNEL_BETA));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("stable", VersionInfo::CHANNEL_STABLE));
+
+  // beta supported.
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("beta", VersionInfo::CHANNEL_UNKNOWN));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("beta", VersionInfo::CHANNEL_CANARY));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("beta", VersionInfo::CHANNEL_DEV));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("beta", VersionInfo::CHANNEL_BETA));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("beta", VersionInfo::CHANNEL_STABLE));
+
+  // dev supported.
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("dev", VersionInfo::CHANNEL_UNKNOWN));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("dev", VersionInfo::CHANNEL_CANARY));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("dev", VersionInfo::CHANNEL_DEV));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("dev", VersionInfo::CHANNEL_BETA));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("dev", VersionInfo::CHANNEL_STABLE));
+
+  // canary supported.
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("canary", VersionInfo::CHANNEL_UNKNOWN));
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("canary", VersionInfo::CHANNEL_CANARY));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("canary", VersionInfo::CHANNEL_DEV));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("canary", VersionInfo::CHANNEL_BETA));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("canary", VersionInfo::CHANNEL_STABLE));
+
+  // trunk supported.
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+      IsAvailableInChannel("trunk", VersionInfo::CHANNEL_UNKNOWN));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("trunk", VersionInfo::CHANNEL_CANARY));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("trunk", VersionInfo::CHANNEL_DEV));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("trunk", VersionInfo::CHANNEL_BETA));
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+      IsAvailableInChannel("trunk", VersionInfo::CHANNEL_STABLE));
+}
+
+}  // namespace