Introduce session type parameter to extension features

extensions/common/features/simple_feature.cc

Index: extensions/common/features/simple_feature.cc
diff --git a/extensions/common/features/simple_feature.cc b/extensions/common/features/simple_feature.cc
index 37a0c80dc2572469423bd7d6ceb31b2d15ca6067..76172cc75b0fd9f70142a7baff84dcfd8931686f 100644
--- a/extensions/common/features/simple_feature.cc
+++ b/extensions/common/features/simple_feature.cc
@@ -207,6 +207,19 @@ std::string GetDisplayName(version_info::Channel channel) {
   return "";
 }
 
+std::string GetSessionTypeDisplayName(FeatureSessionType session_type) {
+  switch (session_type) {
+    case FeatureSessionType::UNKNOWN:
+      return "unknown";
+    case FeatureSessionType::KIOSK:
+      return "kiosk app";
+    case FeatureSessionType::REGULAR:
+      return "regular user";
+    default:
+      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>
@@ -297,6 +310,9 @@ struct SimpleFeature::Mappings {
     channels["dev"] = version_info::Channel::DEV;
     channels["beta"] = version_info::Channel::BETA;
     channels["stable"] = version_info::Channel::STABLE;
+
+    session_types["regular"] = FeatureSessionType::REGULAR;
+    session_types["kiosk"] = FeatureSessionType::KIOSK;
   }
 
   std::map<std::string, Manifest::Type> extension_types;
@@ -304,6 +320,7 @@ struct SimpleFeature::Mappings {
   std::map<std::string, SimpleFeature::Location> locations;
   std::map<std::string, Feature::Platform> platforms;
   std::map<std::string, version_info::Channel> channels;
+  std::map<std::string, FeatureSessionType> session_types;
 };
 
 SimpleFeature::SimpleFeature()
@@ -339,6 +356,9 @@ void SimpleFeature::Parse(const base::DictionaryValue* dictionary) {
     } else if (key == "contexts") {
       ParseEnumVector<Context>(value, &contexts_,
                                mappings.Get().contexts);
+    } else if (key == "session_types") {
+      ParseEnumVector<FeatureSessionType>(value, &session_types_,
+                                          mappings.Get().session_types);
     } else if (key == "location") {
       ParseEnum<Location>(value, &location_, mappings.Get().locations);
     } else if (key == "platforms") {
@@ -448,7 +468,7 @@ Feature::Availability SimpleFeature::IsAvailableToManifest(
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
     const Extension* extension,
-    SimpleFeature::Context context,
+    Feature::Context context,
     const GURL& url,
     SimpleFeature::Platform platform) const {
   if (extension) {
@@ -476,10 +496,16 @@ Feature::Availability SimpleFeature::IsAvailableToContext(
     return CreateAvailability(INVALID_URL, url);
   }
 
+  FeatureSessionType session_type = GetCurrentFeatureSessionType();
+  if (!session_types_.empty() &&
+      !base::ContainsValue(session_types_, 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));
+  return CheckDependencies(base::Bind(&IsAvailableToContextForBind, extension,
+                                      context, url, platform));
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
@@ -487,7 +513,8 @@ std::string SimpleFeature::GetAvailabilityMessage(
     Manifest::Type type,
     const GURL& url,
     Context context,
-    version_info::Channel channel) const {
+    version_info::Channel channel,
+    FeatureSessionType session_type) const {
   switch (result) {
     case IS_AVAILABLE:
       return std::string();
@@ -531,6 +558,10 @@ std::string SimpleFeature::GetAvailabilityMessage(
           "'%s' requires manifest version of %d or lower.",
           name().c_str(),
           max_manifest_version_);
+    case INVALID_SESSION_TYPE:
+      return base::StringPrintf(
+          "'%s' is not allowed in %s session", name().c_str(),
+          GetSessionTypeDisplayName(session_type).c_str());
     case NOT_PRESENT:
       return base::StringPrintf(
           "'%s' requires a different Feature that is not present.",
@@ -553,25 +584,26 @@ std::string SimpleFeature::GetAvailabilityMessage(
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result) const {
   return Availability(
-      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
-                                     UNSPECIFIED_CONTEXT,
-                                     version_info::Channel::UNKNOWN));
+      result, GetAvailabilityMessage(
+                  result, Manifest::TYPE_UNKNOWN, GURL(), UNSPECIFIED_CONTEXT,
+                  version_info::Channel::UNKNOWN, FeatureSessionType::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result, Manifest::Type type) const {
   return Availability(
       result, GetAvailabilityMessage(result, type, GURL(), UNSPECIFIED_CONTEXT,
-                                     version_info::Channel::UNKNOWN));
+                                     version_info::Channel::UNKNOWN,
+                                     FeatureSessionType::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result,
     const GURL& url) const {
   return Availability(
-      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, url,
-                                     UNSPECIFIED_CONTEXT,
-                                     version_info::Channel::UNKNOWN));
+      result, GetAvailabilityMessage(
+                  result, Manifest::TYPE_UNKNOWN, url, UNSPECIFIED_CONTEXT,
+                  version_info::Channel::UNKNOWN, FeatureSessionType::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
@@ -579,7 +611,8 @@ Feature::Availability SimpleFeature::CreateAvailability(
     Context context) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
-                                     context, version_info::Channel::UNKNOWN));
+                                     context, version_info::Channel::UNKNOWN,
+                                     FeatureSessionType::UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
@@ -587,7 +620,17 @@ Feature::Availability SimpleFeature::CreateAvailability(
     version_info::Channel channel) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
-                                     UNSPECIFIED_CONTEXT, channel));
+                                     UNSPECIFIED_CONTEXT, channel,
+                                     FeatureSessionType::UNKNOWN));
+}
+
+Feature::Availability SimpleFeature::CreateAvailability(
+    AvailabilityResult result,
+    FeatureSessionType session_type) const {
+  return Availability(
+      result, GetAvailabilityMessage(
+                  result, Manifest::TYPE_UNKNOWN, GURL(), UNSPECIFIED_CONTEXT,
+                  version_info::Channel::UNKNOWN, session_type));
 }
 
 bool SimpleFeature::IsInternal() const {
@@ -691,6 +734,11 @@ void SimpleFeature::set_extension_types(
   extension_types_ = types;
 }
 
+void SimpleFeature::set_session_types(
+    std::initializer_list<FeatureSessionType> types) {
+  session_types_ = types;
+}
+
 void SimpleFeature::set_matches(
     std::initializer_list<const char* const> matches) {
   matches_.ClearPatterns();