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

chrome/common/extensions/feature_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
+using chrome::VersionInfo;
 using extensions::Feature;
 
 namespace {
 
 struct IsAvailableTestData {
   std::string extension_id;
   Extension::Type extension_type;
   Feature::Location location;
   Feature::Platform platform;
   int manifest_version;
   Feature::Availability expected_result;
 };
 
-}  // namespace
-
 TEST(ExtensionFeatureTest, IsAvailableNullCase) {
   const IsAvailableTestData tests[] = {
     { "", Extension::TYPE_UNKNOWN,
       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
       Feature::IS_AVAILABLE },
     { "random-extension", Extension::TYPE_UNKNOWN,
       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
       Feature::IS_AVAILABLE },
     { "", Extension::TYPE_PACKAGED_APP,
       Feature::UNSPECIFIED_LOCATION, Feature::UNSPECIFIED_PLATFORM, -1,
@@ skipping 374 matching lines @@
   EXPECT_FALSE(feature2.Equals(feature));
 
   feature2 = feature;
   feature2.set_min_manifest_version(0);
   EXPECT_FALSE(feature2.Equals(feature));
 
   feature2 = feature;
   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