Introduce session type parameter to extension features

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>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/test/scoped_command_line.h"
 #include "base/values.h"
 #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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using version_info::Channel;
 
 namespace extensions {
 
 namespace {
 
 struct IsAvailableTestData {
   std::string extension_id;
   Manifest::Type extension_type;
   Manifest::Location location;
   Feature::Platform platform;
   int manifest_version;
   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();
 }
 
 Feature::AvailabilityResult IsAvailableInChannel(Channel channel_for_feature,
                                                  Channel channel_for_testing) {
   ScopedCurrentChannel current_channel(channel_for_testing);
 
   SimpleFeature feature;
@@ skipping 342 matching lines @@
       Feature::CHROMEOS_PLATFORM).result());
   feature.set_min_manifest_version(21);
 
   feature.set_max_manifest_version(18);
   EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION, feature.IsAvailableToContext(
       extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
       Feature::CHROMEOS_PLATFORM).result());
   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,
                                   Manifest::COMPONENT));
   EXPECT_TRUE(LocationIsAvailable(SimpleFeature::EXTERNAL_COMPONENT_LOCATION,
                                   Manifest::COMPONENT));
   EXPECT_TRUE(
       LocationIsAvailable(SimpleFeature::POLICY_LOCATION, Manifest::COMPONENT));
   EXPECT_TRUE(LocationIsAvailable(SimpleFeature::UNSPECIFIED_LOCATION,
                                   Manifest::COMPONENT));
@@ skipping 327 matching lines @@
     EXPECT_NE(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
                                           Manifest::INVALID_LOCATION,
                                           Feature::UNSPECIFIED_PLATFORM)
                   .result());
   }
 }
 
 }  // namespace extensions