Introduce kiosk.autolaunched feature session type

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>
@@ skipping 24 matching lines @@
 namespace {
 
 const char* const kTestFeatures[] = {
     "test1", "test2", "test3",   "test4",   "test5",
     "test6", "test7", "parent1", "parent2", "parent3",
 };
 
 const char* const kAliasTestApis[] = {"alias_api_source"};
 
 const char* const kSessionTypeTestFeatures[] = {
-    "test1", "kiosk_only", "non_kiosk", "multiple_session_types"};
+    "test6", "kiosk_only", "non_kiosk", "multiple_session_types",
+    "autolaunched_kiosk"};
 
 struct FeatureSessionTypesTestData {
   std::string api_name;
   bool expect_available;
   FeatureSessionType current_session_type;
 };
 
 class TestExtensionAPI : public ExtensionAPI {
  public:
   TestExtensionAPI() {}
@@ skipping 274 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, CheckAliasStatus::NOT_ALLOWED))
         << i;
   }
 }
 
 TEST(ExtensionAPITest, SessionTypeFeature) {
+  scoped_refptr<const Extension> app =
+      ExtensionBuilder()
+          .SetManifest(
+              DictionaryBuilder()
+                  .Set("name", "app")
+                  .Set("app",
+                       DictionaryBuilder()
+                           .Set("background",
+                                DictionaryBuilder()
+                                    .Set("scripts", ListBuilder()
+                                                        .Append("background.js")
+                                                        .Build())
+                                    .Build())
+                           .Build())
+                  .Set("version", "1")
+                  .Set("manifest_version", 2)
+                  .Build())
+          .Build();
+
   const std::vector<FeatureSessionTypesTestData> kTestData(
       {{"kiosk_only", true, FeatureSessionType::KIOSK},
+       {"kiosk_only", true, FeatureSessionType::AUTOLAUNCHED_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},
+       {"autolaunched_kiosk", true, FeatureSessionType::AUTOLAUNCHED_KIOSK},
+       {"autolaunched_kiosk", false, FeatureSessionType::KIOSK},
+       {"autolaunched_kiosk", false, FeatureSessionType::REGULAR},
        {"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}});
+       // test6.foo is available to apps and has no session type restrictions.
+       {"test6.foo", true, FeatureSessionType::KIOSK},
+       {"test6.foo", true, FeatureSessionType::AUTOLAUNCHED_KIOSK},
+       {"test6.foo", true, FeatureSessionType::REGULAR},
+       {"test6.foo", 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,
+              api.IsAvailable(test.api_name, app.get(),
                               Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
                               CheckAliasStatus::NOT_ALLOWED)
                   .is_available())
         << "Test case (" << test.api_name << ", "
         << static_cast<int>(test.current_session_type) << ").";
   }
 }
 
 TEST(ExtensionAPITest, LazyGetSchema) {
   std::unique_ptr<ExtensionAPI> apis(
@@ skipping 543 matching lines @@
                                 CheckAliasStatus::NOT_ALLOWED)
                   .is_available());
   EXPECT_FALSE(extension_api
                    ->IsAvailable("pageAction", extension.get(),
                                  Feature::BLESSED_EXTENSION_CONTEXT, GURL(),
                                  CheckAliasStatus::NOT_ALLOWED)
                    .is_available());
 }
 
 }  // namespace extensions