Introduce session type parameter to extension features

chrome/common/extensions/api/common_extension_api_unittest.cc

 // Copyright (c) 2012 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/extension_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_features_unittest.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
+#include "extensions/common/features/feature_session_type.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/test_util.h"
 #include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace {
 
 const char* const kTestFeatures[] = {
     "test1", "test2", "test3",   "test4",   "test5",
     "test6", "test7", "parent1", "parent2", "parent3",
 };
 
+const char* const kSessionTypeTestFeatures[] = {
+    "test1", "kiosk_only", "non_kiosk", "multiple_session_types"};
+
+struct FeatureSessionTypesTestData {
+  std::string api_name;
+  bool expect_available;
+  FeatureSessionType current_session_type;
+};
+
 class TestExtensionAPI : public ExtensionAPI {
  public:
   TestExtensionAPI() {}
   ~TestExtensionAPI() override {}
 
   void add_fake_schema(const std::string& name) { fake_schemas_.insert(name); }
 
  private:
   bool IsKnownAPI(const std::string& name, ExtensionsClient* client) override {
     return fake_schemas_.count(name) != 0;
@@ skipping 223 matching lines @@
     ASSERT_TRUE(test_feature);
     EXPECT_EQ(test_data[i].expect_is_available,
               api.IsAnyFeatureAvailableToContext(*test_feature,
                                                  test_data[i].extension,
                                                  test_data[i].context,
                                                  test_data[i].url))
         << i;
   }
 }
 
+TEST(ExtensionAPITest, SessionTypeFeature) {
+  const std::vector<FeatureSessionTypesTestData> kTestData(
+      {{"kiosk_only", true, FeatureSessionType::KIOSK},
+       {"kiosk_only", false, FeatureSessionType::REGULAR},
+       {"kiosk_only", false, FeatureSessionType::UNKNOWN},
+       {"non_kiosk", false, FeatureSessionType::KIOSK},
+       {"non_kiosk", true, FeatureSessionType::REGULAR},
+       {"non_kiosk", false, FeatureSessionType::UNKNOWN},
+       {"multiple_session_types", true, FeatureSessionType::KIOSK},
+       {"multiple_session_types", true, FeatureSessionType::REGULAR},
+       {"multiple_session_types", false, FeatureSessionType::UNKNOWN},
+       {"test1", true, FeatureSessionType::KIOSK},
+       {"test1", true, FeatureSessionType::REGULAR},
+       {"test1", true, FeatureSessionType::UNKNOWN}});
+
+  UnittestFeatureProvider api_feature_provider;
+
+  for (const auto& test : kTestData) {
+    TestExtensionAPI api;
+    api.RegisterDependencyProvider("api", &api_feature_provider);
+    for (const auto& key : kSessionTypeTestFeatures)
+      api.add_fake_schema(key);
+    ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
+
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> current_session(
+        ScopedCurrentFeatureSessionType(test.current_session_type));
+    EXPECT_EQ(test.expect_available,
+              api.IsAvailable(test.api_name, nullptr,
+                              Feature::BLESSED_EXTENSION_CONTEXT, GURL())
+                  .is_available())
+        << "Test case (" << test.api_name << ", "
+        << static_cast<int>(test.current_session_type) << ").";
+  }
+}
+
 TEST(ExtensionAPITest, LazyGetSchema) {
   std::unique_ptr<ExtensionAPI> apis(
       ExtensionAPI::CreateWithDefaultConfiguration());
 
   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
   EXPECT_EQ(NULL, apis->GetSchema(std::string()));
   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
   EXPECT_EQ(NULL, apis->GetSchema("experimental"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
   EXPECT_EQ(NULL, apis->GetSchema("foo"));
@@ skipping 545 matching lines @@
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions