Introduce kiosk.autolaunched feature session type

extensions/common/features/simple_feature.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 <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 116 matching lines @@
 }
 
 std::string GetDisplayName(FeatureSessionType session_type) {
   switch (session_type) {
     case FeatureSessionType::INITIAL:
       return "user-less";
     case FeatureSessionType::UNKNOWN:
       return "unknown";
     case FeatureSessionType::KIOSK:
       return "kiosk app";
+    case FeatureSessionType::AUTOLAUNCHED_KIOSK:
+      return "auto-launched kiosk app";
     case FeatureSessionType::REGULAR:
       return "regular user";
   }
   return "";
 }
 
 // Gets a human-readable list of the display names (pluralized, comma separated
 // with the "and" in the correct place) for each of |enum_types|.
 template <typename EnumType>
 std::string ListDisplayNames(const std::vector<EnumType>& enum_types) {
@@ skipping 105 matching lines @@
     return CreateAvailability(INVALID_MAX_MANIFEST_VERSION, type);
 
   if (!command_line_switch_.empty() &&
       !IsCommandLineSwitchEnabled(command_line_switch_)) {
     return CreateAvailability(MISSING_COMMAND_LINE_SWITCH, type);
   }
 
   if (channel_ && *channel_ < GetCurrentChannel())
     return CreateAvailability(UNSUPPORTED_CHANNEL, *channel_);
 
-  FeatureSessionType session = GetCurrentFeatureSessionType();
-  if (!session_types_.empty() &&
-      !base::ContainsValue(session_types_, session)) {
-    return CreateAvailability(INVALID_SESSION_TYPE, session);
-  }
+  FeatureSessionType session_type = GetCurrentFeatureSessionType();
+  if (!MatchesSessionTypes(session_type))
+    return CreateAvailability(INVALID_SESSION_TYPE, session_type);
 
   return CheckDependencies(base::Bind(&IsAvailableToManifestForBind,
                                       extension_id,
                                       type,
                                       location,
                                       manifest_version,
                                       platform));
 }
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
@@ skipping 19 matching lines @@
     return CreateAvailability(INVALID_CONTEXT, context);
 
   // TODO(kalman): Consider checking |matches_| regardless of context type.
   // Fewer surprises, and if the feature configuration wants to isolate
   // "matches" from say "blessed_extension" then they can use complex features.
   if ((context == WEB_PAGE_CONTEXT || context == WEBUI_CONTEXT) &&
       !matches_.MatchesURL(url)) {
     return CreateAvailability(INVALID_URL, url);
   }
 
-  FeatureSessionType session = GetCurrentFeatureSessionType();
-  if (!session_types_.empty() &&
-      !base::ContainsValue(session_types_, session)) {
-    return CreateAvailability(INVALID_SESSION_TYPE, session);
+  FeatureSessionType session_type = GetCurrentFeatureSessionType();
+  if (!MatchesSessionTypes(session_type)) {
+    return CreateAvailability(INVALID_SESSION_TYPE, session_type);
   }
 
   // TODO(kalman): Assert that if the context was a webpage or WebUI context
   // then at some point a "matches" restriction was checked.
   return CheckDependencies(base::Bind(&IsAvailableToContextForBind, extension,
                                       context, url, platform));
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
     AvailabilityResult result,
@@ skipping 170 matching lines @@
     case SimpleFeature::EXTERNAL_COMPONENT_LOCATION:
       return manifest_location == Manifest::EXTERNAL_COMPONENT;
     case SimpleFeature::POLICY_LOCATION:
       return manifest_location == Manifest::EXTERNAL_POLICY ||
              manifest_location == Manifest::EXTERNAL_POLICY_DOWNLOAD;
   }
   NOTREACHED();
   return false;
 }
 
+bool SimpleFeature::MatchesSessionTypes(FeatureSessionType session_type) const {
+  if (session_types_.empty())
+    return true;
+
+  if (!base::ContainsValue(session_types_, session_type)) {
+    // AUTOLAUNCHED_KIOSK session type is subset of KIOSK - accept auto-lauched
+    // kiosk session if kiosk session is allowed. This is only exception to
+    // rejecting session type that is not present in |session_types_|
+    return session_type == FeatureSessionType::AUTOLAUNCHED_KIOSK &&

[Devlin, 2016/12/29 17:15:37]

I kind of wonder if this is better done at compile time, by inferring from
kiosk.autolaunched that we should also add kiosk, and then we just keep the
simple base::ContainsValue check here.  WDYT?

[tbarzic, 2016/12/29 20:29:58]

Yeah, that would work,too.
I find this approach slightly easier to follow, in sense that it's easier to
figure out the logic by looking it up in simple_feature.cc than having to go to
feature_compiler in order to notice KIOSK actually maps to 2 types.

+           base::ContainsValue(session_types_, FeatureSessionType::KIOSK);
+  }
+
+  return true;
+}
+
 Feature::Availability SimpleFeature::CheckDependencies(
     const base::Callback<Availability(const Feature*)>& checker) const {
   for (const auto& dep_name : dependencies_) {
     Feature* dependency =
         ExtensionAPI::GetSharedInstance()->GetFeatureDependency(dep_name);
     if (!dependency)
       return CreateAvailability(NOT_PRESENT);
     Availability dependency_availability = checker.Run(dependency);
     if (!dependency_availability.is_available())
       return dependency_availability;
@@ skipping 50 matching lines @@
 void SimpleFeature::set_platforms(std::initializer_list<Platform> platforms) {
   platforms_ = platforms;
 }
 
 void SimpleFeature::set_whitelist(
     std::initializer_list<const char* const> whitelist) {
   whitelist_.assign(whitelist.begin(), whitelist.end());
 }
 
 }  // namespace extensions