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/json_feature_provider.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"
 
 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;
+  bool ignore_session_types;

[Devlin, 2016/08/23 20:49:06]

Why do we need this?  It seems like we should never be ignoring session types.

[tbarzic, 2016/09/08 18:48:55]

it was named a bit poorly, but it's used to distinguish empty session_types and
unset session_types when setting up test, not needed any more since
empty_session type is not a valid value, and essentially gets ignored.

+};
+
 template <class FeatureClass>
 SimpleFeature* CreateFeature() {
   return new FeatureClass();
 }
 
 Feature::AvailabilityResult IsAvailableInChannel(
     const std::string& channel,
     version_info::Channel channel_for_testing) {
   ScopedCurrentChannel current_channel(channel_for_testing);
 
@@ skipping 347 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) {
+  base::DictionaryValue manifest;
+  manifest.SetString("name", "test");
+  manifest.SetString("version", "1");
+  manifest.SetInteger("manifest_version", 21);

[Devlin, 2016/08/23 20:49:06]

?  This didn't throw an error?

[tbarzic, 2016/09/08 18:48:55]

no

+  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},
+        false /* ignore_session_types */},
+       {"kiosk feature in regular session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::REGULAR,
+        {FeatureSessionType::KIOSK},
+        false /* ignore_session_types */},
+       {"kiosk feature in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {FeatureSessionType::KIOSK},
+        false /* ignore_session_types */},
+       {"kiosk feature in initial session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {FeatureSessionType::KIOSK},
+        false /* ignore_session_types */},
+       {"non kiosk feature in kiosk session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::KIOSK,
+        {FeatureSessionType::REGULAR},
+        false /* ignore_session_types */},
+       {"non kiosk feature in regular session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::REGULAR,
+        {FeatureSessionType::REGULAR},
+        false /* ignore_session_types */},
+       {"non kiosk feature in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {FeatureSessionType::REGULAR},
+        false /* ignore_session_types */},
+       {"non kiosk feature in initial session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {FeatureSessionType::REGULAR},
+        false /* ignore_session_types */},
+
+       {"empty session types in kiosk session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::KIOSK,
+        {},
+        false /* ignore_session_types */},
+       {"empty session types in regular session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::REGULAR,
+        {},
+        false /* ignore_session_types */},
+       {"empty session types in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {},
+        false /* ignore_session_types */},
+       {"empty session types in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {},
+        false /* ignore_session_types */},
+
+       {"session agnostic feature in kiosk session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::KIOSK,
+        {},
+        true /* ignore_session_types */},
+       {"session agnostic feature in regular session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::REGULAR,
+        {},
+        true /* ignore_session_types */},
+       {"session agnostic feature in unknown session",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::UNKNOWN,
+        {},
+        true /* ignore_session_types */},
+       {"feature with multiple session types",
+        Feature::IS_AVAILABLE,
+        FeatureSessionType::REGULAR,
+        {FeatureSessionType::REGULAR, FeatureSessionType::KIOSK},
+        false /* ignore_session_types */},
+       {"feature with multiple session types in unknown session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::UNKNOWN,
+        {FeatureSessionType::REGULAR, FeatureSessionType::KIOSK},
+        false /* ignore_session_types */},
+       {"feature with multiple session types in initial session",
+        Feature::INVALID_SESSION_TYPE,
+        FeatureSessionType::INITIAL,
+        {FeatureSessionType::REGULAR, FeatureSessionType::KIOSK},
+        false /* ignore_session_types */}});
+
+  for (const auto& test : kTestData) {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> current_session(
+        ScopedCurrentFeatureSessionType(test.current_session_type));
+
+    SimpleFeature feature;
+    if (!test.ignore_session_types)
+      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 555 matching lines @@
     EXPECT_NE(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
                                           Manifest::INVALID_LOCATION,
                                           Feature::UNSPECIFIED_PLATFORM)
                   .result());
   }
 }
 
 }  // namespace extensions