Remove GetContexts() from the public interface of extensions::Feature. It was

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 "chrome/common/extensions/features/chrome_channel_feature_filter.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 271 matching lines @@
       feature.IsAvailableToManifest(std::string(),
                                     Manifest::TYPE_THEME,
                                     Manifest::INVALID_LOCATION,
                                     -1,
                                     Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Context) {
   SimpleFeature feature;
   feature.set_name("somefeature");
-  feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
+  feature.contexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
   feature.platforms()->insert(Feature::CHROMEOS_PLATFORM);
   feature.set_min_manifest_version(21);
   feature.set_max_manifest_version(25);
 
   base::DictionaryValue manifest;
   manifest.SetString("name", "test");
   manifest.SetString("version", "1");
   manifest.SetInteger("manifest_version", 21);
   manifest.SetString("app.launch.local_path", "foo.html");
@@ skipping 18 matching lines @@
         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
         Feature::CHROMEOS_PLATFORM);
     EXPECT_EQ(Feature::INVALID_TYPE, availability.result());
     EXPECT_EQ("'somefeature' is only allowed for themes, "
               "but this is a legacy packaged app.",
               availability.message());
   }
 
   feature.extension_types()->clear();
   feature.extension_types()->insert(Manifest::TYPE_LEGACY_PACKAGED_APP);
-  feature.GetContexts()->clear();
-  feature.GetContexts()->insert(Feature::UNBLESSED_EXTENSION_CONTEXT);
-  feature.GetContexts()->insert(Feature::CONTENT_SCRIPT_CONTEXT);
+  feature.contexts()->clear();
+  feature.contexts()->insert(Feature::UNBLESSED_EXTENSION_CONTEXT);
+  feature.contexts()->insert(Feature::CONTENT_SCRIPT_CONTEXT);
   {
     Feature::Availability availability = feature.IsAvailableToContext(
         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
         Feature::CHROMEOS_PLATFORM);
     EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
     EXPECT_EQ("'somefeature' is only allowed to run in extension iframes and "
               "content scripts, but this is a privileged page",
               availability.message());
   }
 
-  feature.GetContexts()->insert(Feature::WEB_PAGE_CONTEXT);
+  feature.contexts()->insert(Feature::WEB_PAGE_CONTEXT);
   {
     Feature::Availability availability = feature.IsAvailableToContext(
         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
         Feature::CHROMEOS_PLATFORM);
     EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
     EXPECT_EQ("'somefeature' is only allowed to run in extension iframes, "
               "content scripts, and web pages, but this is a privileged page",
               availability.message());
   }
 
-  feature.GetContexts()->clear();
-  feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
+  feature.contexts()->clear();
+  feature.contexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.set_location(SimpleFeature::COMPONENT_LOCATION);
   EXPECT_EQ(Feature::INVALID_LOCATION, feature.IsAvailableToContext(
       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
       Feature::CHROMEOS_PLATFORM).result());
   feature.set_location(SimpleFeature::UNSPECIFIED_LOCATION);
 
   EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToContext(
       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
       Feature::UNSPECIFIED_PLATFORM).result());
 
@@ skipping 122 matching lines @@
                                     7,
                                     Feature::UNSPECIFIED_PLATFORM).result());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseNull) {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_TRUE(feature->whitelist()->empty());
   EXPECT_TRUE(feature->extension_types()->empty());
-  EXPECT_TRUE(feature->GetContexts()->empty());
+  EXPECT_TRUE(feature->contexts()->empty());
   EXPECT_EQ(SimpleFeature::UNSPECIFIED_LOCATION, feature->location());
   EXPECT_TRUE(feature->platforms()->empty());
   EXPECT_EQ(0, feature->min_manifest_version());
   EXPECT_EQ(0, feature->max_manifest_version());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseWhitelist) {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   base::ListValue* whitelist = new base::ListValue();
   whitelist->Append(new base::StringValue("foo"));
@@ skipping 37 matching lines @@
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   base::ListValue* contexts = new base::ListValue();
   contexts->Append(new base::StringValue("blessed_extension"));
   contexts->Append(new base::StringValue("unblessed_extension"));
   contexts->Append(new base::StringValue("content_script"));
   contexts->Append(new base::StringValue("web_page"));
   contexts->Append(new base::StringValue("blessed_web_page"));
   value->Set("contexts", contexts);
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
-  EXPECT_EQ(5u, feature->GetContexts()->size());
-  EXPECT_TRUE(
-      feature->GetContexts()->count(Feature::BLESSED_EXTENSION_CONTEXT));
-  EXPECT_TRUE(
-      feature->GetContexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT));
-  EXPECT_TRUE(
-      feature->GetContexts()->count(Feature::CONTENT_SCRIPT_CONTEXT));
-  EXPECT_TRUE(
-      feature->GetContexts()->count(Feature::WEB_PAGE_CONTEXT));
-  EXPECT_TRUE(
-      feature->GetContexts()->count(Feature::BLESSED_WEB_PAGE_CONTEXT));
+  EXPECT_EQ(5u, feature->contexts()->size());
+  EXPECT_TRUE(feature->contexts()->count(Feature::BLESSED_EXTENSION_CONTEXT));
+  EXPECT_TRUE(feature->contexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT));
+  EXPECT_TRUE(feature->contexts()->count(Feature::CONTENT_SCRIPT_CONTEXT));
+  EXPECT_TRUE(feature->contexts()->count(Feature::WEB_PAGE_CONTEXT));
+  EXPECT_TRUE(feature->contexts()->count(Feature::BLESSED_WEB_PAGE_CONTEXT));
 
   value->SetString("contexts", "all");
   scoped_ptr<SimpleFeature> feature2(new SimpleFeature());
   feature2->Parse(value.get());
-  EXPECT_EQ(*(feature->GetContexts()), *(feature2->GetContexts()));
+  EXPECT_EQ(*(feature->contexts()), *(feature2->contexts()));
 }
 
 TEST_F(ExtensionSimpleFeatureTest, ParseLocation) {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetString("location", "component");
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(SimpleFeature::COMPONENT_LOCATION, feature->location());
 }
 
@@ skipping 35 matching lines @@
   scoped_ptr<SimpleFeature> feature(new SimpleFeature());
   feature->Parse(value.get());
   EXPECT_EQ(1, feature->min_manifest_version());
   EXPECT_EQ(5, feature->max_manifest_version());
 }
 
 TEST_F(ExtensionSimpleFeatureTest, Inheritance) {
   SimpleFeature feature;
   feature.whitelist()->insert("foo");
   feature.extension_types()->insert(Manifest::TYPE_THEME);
-  feature.GetContexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
+  feature.contexts()->insert(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.set_location(SimpleFeature::COMPONENT_LOCATION);
   feature.platforms()->insert(Feature::CHROMEOS_PLATFORM);
   feature.set_min_manifest_version(1);
   feature.set_max_manifest_version(2);
 
   // Test additive parsing. Parsing an empty dictionary should result in no
   // changes to a SimpleFeature.
   base::DictionaryValue definition;
   feature.Parse(&definition);
   EXPECT_EQ(1u, feature.whitelist()->size());
   EXPECT_EQ(1u, feature.extension_types()->size());
-  EXPECT_EQ(1u, feature.GetContexts()->size());
+  EXPECT_EQ(1u, feature.contexts()->size());
   EXPECT_EQ(1u, feature.whitelist()->count("foo"));
   EXPECT_EQ(SimpleFeature::COMPONENT_LOCATION, feature.location());
   EXPECT_EQ(1u, feature.platforms()->size());
   EXPECT_EQ(1u, feature.platforms()->count(Feature::CHROMEOS_PLATFORM));
   EXPECT_EQ(1, feature.min_manifest_version());
   EXPECT_EQ(2, feature.max_manifest_version());
 
   base::ListValue* whitelist = new base::ListValue();
   base::ListValue* extension_types = new base::ListValue();
   base::ListValue* contexts = new base::ListValue();
   whitelist->Append(new base::StringValue("bar"));
   extension_types->Append(new base::StringValue("extension"));
   contexts->Append(new base::StringValue("unblessed_extension"));
   definition.Set("whitelist", whitelist);
   definition.Set("extension_types", extension_types);
   definition.Set("contexts", contexts);
   // Can't test location or platform because we only have one value so far.
   definition.Set("min_manifest_version", new base::FundamentalValue(2));
   definition.Set("max_manifest_version", new base::FundamentalValue(3));
 
   feature.Parse(&definition);
   EXPECT_EQ(1u, feature.whitelist()->size());
   EXPECT_EQ(1u, feature.extension_types()->size());
-  EXPECT_EQ(1u, feature.GetContexts()->size());
+  EXPECT_EQ(1u, feature.contexts()->size());
   EXPECT_EQ(1u, feature.whitelist()->count("bar"));
   EXPECT_EQ(1u, feature.extension_types()->count(Manifest::TYPE_EXTENSION));
   EXPECT_EQ(1u,
-            feature.GetContexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT));
+            feature.contexts()->count(Feature::UNBLESSED_EXTENSION_CONTEXT));
   EXPECT_EQ(2, feature.min_manifest_version());
   EXPECT_EQ(3, feature.max_manifest_version());
 }
 
 Feature::AvailabilityResult IsAvailableInChannel(
     const std::string& channel, VersionInfo::Channel channel_for_testing) {
   ScopedCurrentChannel current_channel(channel_for_testing);
 
   SimpleFeature feature;
   feature.AddFilter(scoped_ptr<extensions::SimpleFeatureFilter>(
@@ skipping 67 matching lines @@
       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 extensions