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

extensions/common/features/simple_feature_unittest.cc

 // Copyright 2014 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 "extensions/common/features/simple_feature.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 27 matching lines @@
 
 struct FeatureSessionTypeTestData {
   std::string desc;
   Feature::AvailabilityResult expected_availability;
   FeatureSessionType current_session_type;
   std::initializer_list<FeatureSessionType> feature_session_types;
 };
 
 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
 
 class SimpleFeatureTest : public testing::Test {
  protected:
   SimpleFeatureTest() : current_channel_(Channel::UNKNOWN) {}
   bool LocationIsAvailable(SimpleFeature::Location feature_location,
                            Manifest::Location manifest_location) {
     SimpleFeature feature;
@@ skipping 688 matching lines @@
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
             IsAvailableInChannel(Channel::UNKNOWN, Channel::CANARY));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
             IsAvailableInChannel(Channel::UNKNOWN, Channel::DEV));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
             IsAvailableInChannel(Channel::UNKNOWN, Channel::BETA));
   EXPECT_EQ(Feature::UNSUPPORTED_CHANNEL,
             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;
   {
     // Rule: "extension", channel trunk.
     std::unique_ptr<SimpleFeature> feature1(new SimpleFeature());
     feature1->channel_.reset(new Channel(Channel::UNKNOWN));
     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());
     list.push_back(feature2.release());
     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,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
                                           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);
     EXPECT_EQ(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest(
                       "2", Manifest::TYPE_LEGACY_PACKAGED_APP,
                       Manifest::INVALID_LOCATION, Feature::UNSPECIFIED_PLATFORM)
                   .result());
-  }
-  {
-    ScopedCurrentChannel current_channel(Channel::BETA);
     EXPECT_NE(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
+                                          Manifest::INVALID_LOCATION,
+                                          Feature::UNSPECIFIED_PLATFORM)
+                  .result());
+  }
+  {
+    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,
                                           Manifest::INVALID_LOCATION,
                                           Feature::UNSPECIFIED_PLATFORM)
                   .result());
   }
 }
 
 }  // namespace extensions