Support a "policy" extension location in extension features files. At the same

extensions/common/features/complex_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/complex_feature.h"
 
 #include "chrome/common/extensions/features/chrome_channel_feature_filter.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "extensions/common/features/api_feature.h"
 #include "extensions/common/features/simple_feature.h"
@@ skipping 52 matching lines @@
   rule = DictionaryBuilder()
       .Set("whitelist", ListBuilder().Append(kIdBar))
       .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.
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
-      kIdFoo,
-      Manifest::TYPE_EXTENSION,
-      Feature::UNSPECIFIED_LOCATION,
-      Feature::UNSPECIFIED_PLATFORM,
-      Feature::GetCurrentPlatform()).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature->IsAvailableToManifest(kIdFoo,
+                                     Manifest::TYPE_EXTENSION,
+                                     Manifest::INVALID_LOCATION,
+                                     Feature::UNSPECIFIED_PLATFORM,
+                                     Feature::GetCurrentPlatform()).result());
 
   // Test match 2nd rule.
-  EXPECT_EQ(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
-      kIdBar,
-      Manifest::TYPE_LEGACY_PACKAGED_APP,
-      Feature::UNSPECIFIED_LOCATION,
-      Feature::UNSPECIFIED_PLATFORM,
-      Feature::GetCurrentPlatform()).result());
+  EXPECT_EQ(
+      Feature::IS_AVAILABLE,
+      feature->IsAvailableToManifest(kIdBar,
+                                     Manifest::TYPE_LEGACY_PACKAGED_APP,
+                                     Manifest::INVALID_LOCATION,
+                                     Feature::UNSPECIFIED_PLATFORM,
+                                     Feature::GetCurrentPlatform()).result());
 
   // Test whitelist with wrong extension type.
-  EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(
-      kIdBar,
-      Manifest::TYPE_EXTENSION,
-      Feature::UNSPECIFIED_LOCATION,
-      Feature::UNSPECIFIED_PLATFORM,
-      Feature::GetCurrentPlatform()).result());
-  EXPECT_NE(Feature::IS_AVAILABLE, feature->IsAvailableToManifest(kIdFoo,
-      Manifest::TYPE_LEGACY_PACKAGED_APP,
-      Feature::UNSPECIFIED_LOCATION,
-      Feature::UNSPECIFIED_PLATFORM,
-      Feature::GetCurrentPlatform()).result());
+  EXPECT_NE(
+      Feature::IS_AVAILABLE,
+      feature->IsAvailableToManifest(kIdBar,
+                                     Manifest::TYPE_EXTENSION,
+                                     Manifest::INVALID_LOCATION,
+                                     Feature::UNSPECIFIED_PLATFORM,
+                                     Feature::GetCurrentPlatform()).result());
+  EXPECT_NE(
+      Feature::IS_AVAILABLE,
+      feature->IsAvailableToManifest(kIdFoo,
+                                     Manifest::TYPE_LEGACY_PACKAGED_APP,
+                                     Manifest::INVALID_LOCATION,
+                                     Feature::UNSPECIFIED_PLATFORM,
+                                     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,
-        Feature::UNSPECIFIED_LOCATION,
-        Feature::UNSPECIFIED_PLATFORM,
-        Feature::GetCurrentPlatform()).result());
+    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,
-        Feature::UNSPECIFIED_LOCATION,
-        Feature::UNSPECIFIED_PLATFORM,
-        Feature::GetCurrentPlatform()).result());
+    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,
-        Feature::UNSPECIFIED_LOCATION,
-        Feature::UNSPECIFIED_PLATFORM,
-        Feature::GetCurrentPlatform()).result());
+    EXPECT_NE(
+        Feature::IS_AVAILABLE,
+        feature->IsAvailableToManifest("1",
+                                       Manifest::TYPE_EXTENSION,
+                                       Manifest::INVALID_LOCATION,
+                                       Feature::UNSPECIFIED_PLATFORM,
+                                       Feature::GetCurrentPlatform()).result());
   }
 }
 
 // Tests a complex feature with blocked_in_service_worker returns true for
 // IsBlockedInServiceWorker().
 TEST_F(ExtensionComplexFeatureTest, BlockedInServiceWorker) {
   scoped_ptr<ComplexFeature::FeatureList> features(
       new ComplexFeature::FeatureList());
 
   // Two feature rules, both with blocked_in_service_worker: true.
@@ skipping 34 matching lines @@
   api_feature->Parse(ParseJsonDictionaryWithSingleQuotes(
                          "{"
                          "  'channel': 'stable'"
                          "}").get());
   features->push_back(api_feature.release());
 
   EXPECT_FALSE(ComplexFeature(features.Pass()).IsBlockedInServiceWorker());
 }
 
 }  // namespace