Move most extension feature unit tests to extensions_unittests

They don't need to run in Chrome's unit_tests suite any more.

The tests that depend on Chrome's version channel information move to
ChromeChannelFeatureFilterTest.

BUG=413319,397165
TEST=unit_tests ChromeChannelFeatureFilterTest.* and extensions_unittests

Review URL: https://codereview.chromium.org/563923004

Cr-Commit-Position: refs/heads/master@{#294627}

chrome/chrome_tests_unit.gypi

@@ -534,9 +534,6 @@
         # extensions_unittests running in the bots yet. Until that happens,
         # they should be kept here.
         '../extensions/common/extension_l10n_util_unittest.cc',
-        '../extensions/common/features/base_feature_provider_unittest.cc',
-        '../extensions/common/features/complex_feature_unittest.cc',
-        '../extensions/common/features/simple_feature_unittest.cc',
         '../extensions/common/file_util_unittest.cc',
         '../extensions/common/manifest_handlers/externally_connectable_unittest.cc',
         '../extensions/common/manifest_handlers/file_handler_manifest_unittest.cc',
@@ -1796,6 +1793,7 @@
         'common/extensions/extension_icon_set_unittest.cc',
         'common/extensions/extension_unittest.cc',
         'common/extensions/feature_switch_unittest.cc',
+        'common/extensions/features/chrome_channel_feature_filter_unittest.cc',
         'common/extensions/manifest_handlers/automation_unittest.cc',
         'common/extensions/manifest_handlers/content_scripts_manifest_unittest.cc',
         'common/extensions/manifest_handlers/exclude_matches_manifest_unittest.cc',
@@ -2095,6 +2093,7 @@
             'browser/signin/easy_unlock_screenlock_state_handler_unittest.cc',
             'browser/web_applications/web_app_unittest.cc',
             'common/extensions/sync_type_unittest.cc',
+            'common/extensions/features/chrome_channel_feature_filter_unittest.cc',
             'common/extensions/permissions/permission_set_unittest.cc',
             'common/extensions/permissions/permissions_data_unittest.cc',
             'renderer/extensions/extension_localization_peer_unittest.cc',

chrome/common/extensions/api/_manifest_features.json

@@ -119,10 +119,6 @@
     "channel": "stable",
     "extension_types": "all"
   },
-  "description": {
-    "channel": "stable",
-    "extension_types": "all"
-  },
   "devtools_page": {
     "channel": "stable",
     "extension_types": ["extension", "legacy_packaged_app"]

chrome/common/extensions/api/_permission_features.json

@@ -113,21 +113,6 @@
       ]
     }
   ],
-  "bluetoothPrivate": {
-    "channel": "stable",
-    "extension_types": ["platform_app"],
-    "platforms": ["chromeos", "win", "mac"],
-    "whitelist": [
-      "1C93BD3CF875F4A73C0B2A163BB8FBDA8B8B3D80",  // http://crbug.com/387169
-      "A3BC37E2148AC4E99BE4B16AF9D42DD1E592BBBE",  // http://crbug.com/387169
-      "E703483CEF33DEC18B4B6DD84B5C776FB9182BDB",  // http://crbug.com/387169
-      "307E96539209F95A1A8740C713E6998A73657D96",  // http://crbug.com/387169
-      "4F25792AF1AA7483936DE29C07806F203C7170A0",  // http://crbug.com/407693
-      "BD8781D757D830FC2E85470A1B6E8A718B7EE0D9",  // http://crbug.com/407693
-      "4AC2B6C63C6480D150DFDA13E4A5956EB1D0DDBB",  // http://crbug.com/407693
-      "81986D4F846CEDDDB962643FA501D1780DD441BB"   // http://crbug.com/407693
-    ]
-  },
   "bookmarkManagerPrivate": {
     "channel": "stable",
     "extension_types": ["extension", "legacy_packaged_app"],

chrome/common/extensions/features/chrome_channel_feature_filter.cc

@@ -5,6 +5,7 @@
 #include "chrome/common/extensions/features/chrome_channel_feature_filter.h"
 
 #include <map>
+#include <string>
 
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
@@ -53,7 +54,10 @@ chrome::VersionInfo::Channel GetChannelValue(const std::string& name) {
 }  // namespace
 
 ChromeChannelFeatureFilter::ChromeChannelFeatureFilter(SimpleFeature* feature)
-    : SimpleFeatureFilter(feature), channel_has_been_set_(false) {}
+    : SimpleFeatureFilter(feature),
+      channel_has_been_set_(false),
+      channel_(chrome::VersionInfo::CHANNEL_UNKNOWN) {
+}
 
 ChromeChannelFeatureFilter::~ChromeChannelFeatureFilter() {}
 

extensions/common/api/_manifest_features.json

@@ -66,6 +66,10 @@
     // app.content_security_policy whitelist).
     "extension_types": ["extension", "legacy_packaged_app"]
   },
+  "description": {
+    "channel": "stable",
+    "extension_types": "all"
+  },
   "incognito": [
     {
       "channel": "stable",

extensions/common/api/_permission_features.json

@@ -120,6 +120,21 @@
       ]
     }
   ],
+  "bluetoothPrivate": {
+    "channel": "stable",
+    "extension_types": ["platform_app"],
+    "platforms": ["chromeos", "win", "mac"],
+    "whitelist": [
+      "1C93BD3CF875F4A73C0B2A163BB8FBDA8B8B3D80",  // http://crbug.com/387169
+      "A3BC37E2148AC4E99BE4B16AF9D42DD1E592BBBE",  // http://crbug.com/387169
+      "E703483CEF33DEC18B4B6DD84B5C776FB9182BDB",  // http://crbug.com/387169
+      "307E96539209F95A1A8740C713E6998A73657D96",  // http://crbug.com/387169
+      "4F25792AF1AA7483936DE29C07806F203C7170A0",  // http://crbug.com/407693
+      "BD8781D757D830FC2E85470A1B6E8A718B7EE0D9",  // http://crbug.com/407693
+      "4AC2B6C63C6480D150DFDA13E4A5956EB1D0DDBB",  // http://crbug.com/407693
+      "81986D4F846CEDDDB962643FA501D1780DD441BB"   // http://crbug.com/407693
+    ]
+  },
   "dns": [
     {
       "channel": "dev",

extensions/common/features/complex_feature_unittest.cc

@@ -4,48 +4,23 @@
 
 #include "extensions/common/features/complex_feature.h"
 
-#include "chrome/common/extensions/features/chrome_channel_feature_filter.h"
-#include "chrome/common/extensions/features/feature_channel.h"
+#include <string>
+
 #include "extensions/common/features/simple_feature.h"
+#include "extensions/common/manifest.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using chrome::VersionInfo;
-using extensions::ComplexFeature;
-using extensions::DictionaryBuilder;
-using extensions::Feature;
-using extensions::ListBuilder;
-using extensions::Manifest;
-using extensions::ScopedCurrentChannel;
-using extensions::SimpleFeature;
-
-namespace {
-
-class ExtensionComplexFeatureTest : public testing::Test {
- protected:
-  ExtensionComplexFeatureTest()
-      : current_channel_(VersionInfo::CHANNEL_UNKNOWN) {}
-  virtual ~ExtensionComplexFeatureTest() {}
-
-  SimpleFeature* CreateFeature() {
-    SimpleFeature* feature = new SimpleFeature();
-    feature->AddFilter(scoped_ptr<extensions::SimpleFeatureFilter>(
-        new extensions::ChromeChannelFeatureFilter(feature)));
-    return feature;
-  }
-
- private:
-  ScopedCurrentChannel current_channel_;
-};
-
-TEST_F(ExtensionComplexFeatureTest, MultipleRulesWhitelist) {
+namespace extensions {
+
+TEST(ComplexFeatureTest, MultipleRulesWhitelist) {
   const std::string kIdFoo("fooabbbbccccddddeeeeffffgggghhhh");
   const std::string kIdBar("barabbbbccccddddeeeeffffgggghhhh");
   scoped_ptr<ComplexFeature::FeatureList> features(
       new ComplexFeature::FeatureList());
 
   // Rule: "extension", whitelist "foo".
-  scoped_ptr<SimpleFeature> simple_feature(CreateFeature());
+  scoped_ptr<SimpleFeature> simple_feature(new SimpleFeature);
   scoped_ptr<base::DictionaryValue> rule(
       DictionaryBuilder()
       .Set("whitelist", ListBuilder().Append(kIdFoo))
@@ -55,7 +30,7 @@ TEST_F(ExtensionComplexFeatureTest, MultipleRulesWhitelist) {
   features->push_back(simple_feature.release());
 
   // Rule: "legacy_packaged_app", whitelist "bar".
-  simple_feature.reset(CreateFeature());
+  simple_feature.reset(new SimpleFeature);
   rule = DictionaryBuilder()
       .Set("whitelist", ListBuilder().Append(kIdBar))
       .Set("extension_types", ListBuilder()
@@ -100,83 +75,23 @@ TEST_F(ExtensionComplexFeatureTest, MultipleRulesWhitelist) {
                                      Feature::GetCurrentPlatform()).result());
 }
 
-TEST_F(ExtensionComplexFeatureTest, MultipleRulesChannels) {
-  scoped_ptr<ComplexFeature::FeatureList> features(
-      new ComplexFeature::FeatureList());
-
-  // Rule: "extension", channel trunk.
-  scoped_ptr<SimpleFeature> simple_feature(CreateFeature());
-  scoped_ptr<base::DictionaryValue> rule(
-      DictionaryBuilder()
-      .Set("channel", "trunk")
-      .Set("extension_types", ListBuilder().Append("extension")).Build());
-  simple_feature->Parse(rule.get());
-  features->push_back(simple_feature.release());
-
-  // Rule: "legacy_packaged_app", channel stable.
-  simple_feature.reset(CreateFeature());
-  rule = DictionaryBuilder()
-      .Set("channel", "stable")
-      .Set("extension_types", ListBuilder()
-          .Append("legacy_packaged_app")).Build();
-  simple_feature->Parse(rule.get());
-  features->push_back(simple_feature.release());
-
-  scoped_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
-
-  // Test match 1st rule.
-  {
-    ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_UNKNOWN);
-    EXPECT_EQ(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("1",
-                                       Manifest::TYPE_EXTENSION,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM,
-                                       Feature::GetCurrentPlatform()).result());
-  }
-
-  // Test match 2nd rule.
-  {
-    ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_BETA);
-    EXPECT_EQ(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("2",
-                                       Manifest::TYPE_LEGACY_PACKAGED_APP,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM,
-                                       Feature::GetCurrentPlatform()).result());
-  }
-
-  // Test feature not available to extensions above channel unknown.
-  {
-    ScopedCurrentChannel current_channel(VersionInfo::CHANNEL_BETA);
-    EXPECT_NE(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("1",
-                                       Manifest::TYPE_EXTENSION,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM,
-                                       Feature::GetCurrentPlatform()).result());
-  }
-}
-
 // Tests that dependencies are correctly checked.
-TEST_F(ExtensionComplexFeatureTest, Dependencies) {
+TEST(ComplexFeatureTest, Dependencies) {
   scoped_ptr<ComplexFeature::FeatureList> features(
       new ComplexFeature::FeatureList());
 
-  // Rule which depends on an extension-only feature (omnibox).
-  scoped_ptr<SimpleFeature> simple_feature(CreateFeature());
+  // Rule which depends on an extension-only feature (content_security_policy).
+  scoped_ptr<SimpleFeature> simple_feature(new SimpleFeature);
   scoped_ptr<base::DictionaryValue> rule =
       DictionaryBuilder()
-          .Set("dependencies", ListBuilder().Append("manifest:omnibox"))
+          .Set("dependencies",
+               ListBuilder().Append("manifest:content_security_policy"))
           .Build();
   simple_feature->Parse(rule.get());
   features->push_back(simple_feature.release());
 
   // Rule which depends on an platform-app-only feature (serial).
-  simple_feature.reset(CreateFeature());
+  simple_feature.reset(new SimpleFeature);
   rule = DictionaryBuilder()
              .Set("dependencies", ListBuilder().Append("permission:serial"))
              .Build();
@@ -185,7 +100,7 @@ TEST_F(ExtensionComplexFeatureTest, Dependencies) {
 
   scoped_ptr<ComplexFeature> feature(new ComplexFeature(features.Pass()));
 
-  // Available to extensions because of the omnibox rule.
+  // Available to extensions because of the content_security_policy rule.
   EXPECT_EQ(
       Feature::IS_AVAILABLE,
       feature->IsAvailableToManifest("extensionid",
@@ -194,7 +109,7 @@ TEST_F(ExtensionComplexFeatureTest, Dependencies) {
                                      Feature::UNSPECIFIED_PLATFORM,
                                      Feature::GetCurrentPlatform()).result());
 
-  // Available to platofrm apps because of the serial rule.
+  // Available to platform apps because of the serial rule.
   EXPECT_EQ(
       Feature::IS_AVAILABLE,
       feature->IsAvailableToManifest("platformappid",
@@ -213,4 +128,4 @@ TEST_F(ExtensionComplexFeatureTest, Dependencies) {
                                      Feature::GetCurrentPlatform()).result());
 }
 
-}  // namespace
+}  // namespace extensions

extensions/extensions.gyp

@@ -1098,6 +1098,9 @@
         'common/event_filter_unittest.cc',
         'common/extension_resource_unittest.cc',
         'common/extension_set_unittest.cc',
+        'common/features/base_feature_provider_unittest.cc',
+        'common/features/complex_feature_unittest.cc',
+        'common/features/simple_feature_unittest.cc',
         'common/manifest_handler_unittest.cc',
         'common/message_bundle_unittest.cc',
         'common/one_shot_event_unittest.cc',