Introduce session type parameter to extension features

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 58672b114c608c484d73b5772dccddebeaad6640..a4ccdd8b31842d454a59570c7aad0913c0873dcf 100644
--- a/extensions/common/features/simple_feature_unittest.cc
+++ b/extensions/common/features/simple_feature_unittest.cc
@@ -7,6 +7,7 @@
 #include <stddef.h>
 
 #include <string>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ -16,6 +17,7 @@
 #include "extensions/common/features/api_feature.h"
 #include "extensions/common/features/complex_feature.h"
 #include "extensions/common/features/feature_channel.h"
+#include "extensions/common/features/feature_session_type.h"
 #include "extensions/common/features/permission_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/value_builder.h"
@@ -36,6 +38,13 @@ struct IsAvailableTestData {
   Feature::AvailabilityResult expected_result;
 };
 
+struct FeatureSessionTypeTestData {
+  std::string desc;
+  Feature::AvailabilityResult expected_availability;
+  FeatureSessionType current_session_type;
+  std::initializer_list<FeatureSessionType> feature_session_types;
+};
+
 template <class FeatureClass>
 SimpleFeature* CreateFeature() {
   return new FeatureClass();
@@ -398,6 +407,104 @@ TEST_F(SimpleFeatureTest, Context) {
   feature.set_max_manifest_version(25);
 }
 
+TEST_F(SimpleFeatureTest, SessionType) {

[Devlin, 2016/09/12 22:33:08]

Does this test add significant benefit over the other?

[tbarzic, 2016/09/12 23:05:10]

yeah, it tests Feature::IsAvailableToContext rather than
ExtensionAPI::IsAvailable (former is called by later, though).
Plus, IsAvailableToManifest is not included in other test at all.

(note that the other test includes parsing features' json file, instead of
dealing with FeatureSessionType enums directly).

[Devlin, 2016/09/13 16:46:23]

IsAvailable() calls IsAvailableToContext() which calls IsAvailableToManifest(),
so I'm a little dubious about this.  But unittests are cheap, so if you want to
keep it, that's fine.

[tbarzic, 2016/09/13 17:23:49]

IsAvailableToContext does not call into IsAvailableToManifest if extension is
not set (which is the case in common_extension_api_unittest_).

+  base::DictionaryValue manifest;
+  manifest.SetString("name", "test");
+  manifest.SetString("version", "1");
+  manifest.SetInteger("manifest_version", 2);
+  manifest.SetString("app.launch.local_path", "foo.html");
+
+  std::string error;
+  scoped_refptr<const Extension> extension(
+      Extension::Create(base::FilePath(), Manifest::INTERNAL, manifest,
+                        Extension::NO_FLAGS, &error));
+  EXPECT_EQ("", error);
+  ASSERT_TRUE(extension.get());
+
+  const std::vector<FeatureSessionTypeTestData> kTestData(
+      {{"kiosk_feature in kiosk session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::KIOSK,
+        {FeatureSessionType::KIOSK}},
+       {"kiosk feature in regular session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::REGULAR,
+        {FeatureSessionType::KIOSK}},
+       {"kiosk feature in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {FeatureSessionType::KIOSK}},
+       {"kiosk feature in initial session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {FeatureSessionType::KIOSK}},
+       {"non kiosk feature in kiosk session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::KIOSK,
+        {FeatureSessionType::REGULAR}},
+       {"non kiosk feature in regular session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::REGULAR,
+        {FeatureSessionType::REGULAR}},
+       {"non kiosk feature in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {FeatureSessionType::REGULAR}},
+       {"non kiosk feature in initial session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {FeatureSessionType::REGULAR}},
+       {"session agnostic feature in kiosk session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::KIOSK,
+        {}},
+       {"session agnostic feature in regular session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::REGULAR,
+        {}},
+       {"session agnostic feature in unknown session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::UNKNOWN,
+        {}},
+       {"feature with multiple session types",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::REGULAR,
+        {FeatureSessionType::REGULAR, FeatureSessionType::KIOSK}},
+       {"feature with multiple session types in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {FeatureSessionType::REGULAR, FeatureSessionType::KIOSK}},
+       {"feature with multiple session types in initial session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {FeatureSessionType::REGULAR, FeatureSessionType::KIOSK}}});
+
+  for (const auto& test : kTestData) {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> current_session(
+        ScopedCurrentFeatureSessionType(test.current_session_type));
+
+    SimpleFeature feature;
+    feature.set_session_types(test.feature_session_types);
+
+    EXPECT_EQ(test.expected_availability,
+              feature
+                  .IsAvailableToContext(extension.get(),
+                                        Feature::BLESSED_EXTENSION_CONTEXT,
+                                        Feature::CHROMEOS_PLATFORM)
+                  .result())
+        << "Failed test '" << test.desc << "'.";
+
+    EXPECT_EQ(
+        test.expected_availability,
+        feature
+            .IsAvailableToManifest(extension->id(), Manifest::TYPE_UNKNOWN,
+                                   Manifest::INVALID_LOCATION, -1,
+                                   Feature::CHROMEOS_PLATFORM)
+            .result())
+        << "Failed test '" << test.desc << "'.";
+  }
+}
+
 TEST_F(SimpleFeatureTest, Location) {
   // Component extensions can access any location.
   EXPECT_TRUE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,