Extensions: Only create Web request rules registry if Declarative Web Request is enabled.

extensions/common/features/simple_feature_unittest.cc

Index: extensions/common/features/simple_feature_unittest.cc
diff --git a/extensions/common/features/simple_feature_unittest.cc b/extensions/common/features/simple_feature_unittest.cc
index a570248922170a3db7529953129d3533e75aa1ae..3867009344e4ff881f105985552acb770c626117 100644
--- a/extensions/common/features/simple_feature_unittest.cc
+++ b/extensions/common/features/simple_feature_unittest.cc
@@ -45,15 +45,9 @@ struct FeatureSessionTypeTestData {
 
 Feature::AvailabilityResult IsAvailableInChannel(Channel channel_for_feature,
                                                  Channel channel_for_testing) {
-  ScopedCurrentChannel current_channel(channel_for_testing);
-
   SimpleFeature feature;
   feature.set_channel(channel_for_feature);
-  return feature
-      .IsAvailableToManifest("random-extension", Manifest::TYPE_UNKNOWN,
-                             Manifest::INVALID_LOCATION, -1,
-                             Feature::GetCurrentPlatform())
-      .result();
+  return feature.IsAvailableToChannel(channel_for_testing).result();
 }
 
 }  // namespace
@@ -762,56 +756,6 @@ TEST_F(SimpleFeatureTest, SupportedChannel) {
             IsAvailableInChannel(Channel::UNKNOWN, Channel::STABLE));
 }
 
-// Tests simple feature availability across channels.
-TEST_F(SimpleFeatureTest, SimpleFeatureAvailability) {

[karandeepb, 2017/02/18 02:00:29]

Deleted this test (Diff isn't clear on that). It wasn't actually testing Simple
feature availability and was testing the same things as the next test.

-  std::unique_ptr<ComplexFeature> complex_feature;
-  {
-    std::unique_ptr<SimpleFeature> feature1(new SimpleFeature());
-    feature1->channel_.reset(new Channel(Channel::BETA));
-    feature1->extension_types_.push_back(Manifest::TYPE_EXTENSION);
-    std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
-    feature2->channel_.reset(new Channel(Channel::BETA));
-    feature2->extension_types_.push_back(Manifest::TYPE_LEGACY_PACKAGED_APP);
-    std::vector<Feature*> list;
-    list.push_back(feature1.release());
-    list.push_back(feature2.release());
-    complex_feature.reset(new ComplexFeature(&list));
-  }
-
-  Feature* feature = static_cast<Feature*>(complex_feature.get());
-  // Make sure both rules are applied correctly.
-  {
-    ScopedCurrentChannel current_channel(Channel::BETA);
-    EXPECT_EQ(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("1",
-                                       Manifest::TYPE_EXTENSION,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM).result());
-    EXPECT_EQ(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("2",
-                                       Manifest::TYPE_LEGACY_PACKAGED_APP,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM).result());
-  }
-  {
-    ScopedCurrentChannel current_channel(Channel::STABLE);
-    EXPECT_NE(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("1",
-                                       Manifest::TYPE_EXTENSION,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM).result());
-    EXPECT_NE(
-        Feature::IS_AVAILABLE,
-        feature->IsAvailableToManifest("2",
-                                       Manifest::TYPE_LEGACY_PACKAGED_APP,
-                                       Manifest::INVALID_LOCATION,
-                                       Feature::UNSPECIFIED_PLATFORM).result());
-  }
-}
-
 // Tests complex feature availability across channels.
 TEST_F(SimpleFeatureTest, ComplexFeatureAvailability) {
   std::unique_ptr<ComplexFeature> complex_feature;
@@ -822,7 +766,7 @@ TEST_F(SimpleFeatureTest, ComplexFeatureAvailability) {
     feature1->extension_types_.push_back(Manifest::TYPE_EXTENSION);
     std::unique_ptr<SimpleFeature> feature2(new SimpleFeature());
     // Rule: "legacy_packaged_app", channel stable.

[Devlin, 2017/02/18 07:50:07]

nit: update this comment -> channel beta

[karandeepb, 2017/02/21 18:47:08]

Done.

-    feature2->channel_.reset(new Channel(Channel::STABLE));
+    feature2->channel_.reset(new Channel(Channel::BETA));
     feature2->extension_types_.push_back(Manifest::TYPE_LEGACY_PACKAGED_APP);
     std::vector<Feature*> list;
     list.push_back(feature1.release());
@@ -830,7 +774,18 @@ TEST_F(SimpleFeatureTest, ComplexFeatureAvailability) {
     complex_feature.reset(new ComplexFeature(&list));
   }
 
-  Feature* feature = static_cast<Feature*>(complex_feature.get());
+  Feature* feature = complex_feature.get();
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+            feature->IsAvailableToChannel(Channel::UNKNOWN).result());
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+            feature->IsAvailableToChannel(Channel::CANARY).result());
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+            feature->IsAvailableToChannel(Channel::DEV).result());
+  EXPECT_EQ(Feature::IS_AVAILABLE,
+            feature->IsAvailableToChannel(Channel::BETA).result());
+  EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
+            feature->IsAvailableToChannel(Channel::STABLE).result());
+
   {
     ScopedCurrentChannel current_channel(Channel::UNKNOWN);
     EXPECT_EQ(Feature::IS_AVAILABLE,
@@ -839,6 +794,12 @@ TEST_F(SimpleFeatureTest, ComplexFeatureAvailability) {
                                           Manifest::INVALID_LOCATION,
                                           Feature::UNSPECIFIED_PLATFORM)
                   .result());
+    EXPECT_EQ(Feature::IS_AVAILABLE,
+              feature
+                  ->IsAvailableToManifest(
+                      "1", Manifest::TYPE_LEGACY_PACKAGED_APP,
+                      Manifest::INVALID_LOCATION, Feature::UNSPECIFIED_PLATFORM)
+                  .result());
   }
   {
     ScopedCurrentChannel current_channel(Channel::BETA);
@@ -848,9 +809,21 @@ TEST_F(SimpleFeatureTest, ComplexFeatureAvailability) {
                       "2", Manifest::TYPE_LEGACY_PACKAGED_APP,
                       Manifest::INVALID_LOCATION, Feature::UNSPECIFIED_PLATFORM)
                   .result());
+    EXPECT_NE(Feature::IS_AVAILABLE,
+              feature
+                  ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
+                                          Manifest::INVALID_LOCATION,
+                                          Feature::UNSPECIFIED_PLATFORM)
+                  .result());
   }
   {
-    ScopedCurrentChannel current_channel(Channel::BETA);
+    ScopedCurrentChannel current_channel(Channel::STABLE);
+    EXPECT_NE(Feature::IS_AVAILABLE,
+              feature
+                  ->IsAvailableToManifest(
+                      "2", Manifest::TYPE_LEGACY_PACKAGED_APP,
+                      Manifest::INVALID_LOCATION, Feature::UNSPECIFIED_PLATFORM)
+                  .result());
     EXPECT_NE(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,