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..965b5b413975c69302f797818b15e3260a7b3990 100644
--- a/extensions/common/features/simple_feature.cc
+++ b/extensions/common/features/simple_feature.cc
@@ -207,6 +207,21 @@ std::string GetDisplayName(version_info::Channel channel) {
   return "";
 }
 
+std::string GetSessionTypeDisplayName(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::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 +312,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,10 +322,12 @@ 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()
-    : location_(UNSPECIFIED_LOCATION),
+    : session_types_set_(false),
+      location_(UNSPECIFIED_LOCATION),
       min_manifest_version_(0),
       max_manifest_version_(0),
       component_extensions_auto_granted_(true),
@@ -339,6 +359,10 @@ void SimpleFeature::Parse(const base::DictionaryValue* dictionary) {
     } else if (key == "contexts") {
       ParseEnumVector<Context>(value, &contexts_,
                                mappings.Get().contexts);
+    } else if (key == "session_types") {
+      session_types_set_ = true;
+      ParseEnumVector<FeatureSessionType>(value, &session_types_,
+                                          mappings.Get().session_types);
     } else if (key == "location") {
       ParseEnum<Location>(value, &location_, mappings.Get().locations);
     } else if (key == "platforms") {
@@ -438,6 +462,11 @@ Feature::Availability SimpleFeature::IsAvailableToManifest(
   if (channel_ && *channel_ < GetCurrentChannel())
     return CreateAvailability(UNSUPPORTED_CHANNEL, *channel_);
 
+  FeatureSessionType session = GetCurrentFeatureSessionType();
+  if (session_types_set_ && !base::ContainsValue(session_types_, session)) {
+    return CreateAvailability(INVALID_SESSION_TYPE, session);
+  }
+
   return CheckDependencies(base::Bind(&IsAvailableToManifestForBind,
                                       extension_id,
                                       type,
@@ -448,7 +477,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 +505,15 @@ Feature::Availability SimpleFeature::IsAvailableToContext(
     return CreateAvailability(INVALID_URL, url);
   }
 
+  FeatureSessionType session = GetCurrentFeatureSessionType();
+  if (session_types_set_ && !base::ContainsValue(session_types_, session)) {
+    return CreateAvailability(INVALID_SESSION_TYPE, session);
+  }
+
   // 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 +521,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 +566,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(),

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

Let's structure this in the fashion of the other warnings

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

Isn't it already (except of missing trailing .)?

[Devlin, 2016/09/12 22:33:07]

Follow the style of e.g. invalid context errors so that developers know which
sessions something is available in.

[tbarzic, 2016/09/12 23:05:10]

Done.

+          GetSessionTypeDisplayName(session_type).c_str());
     case NOT_PRESENT:
       return base::StringPrintf(
           "'%s' requires a different Feature that is not present.",
@@ -553,25 +592,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 +619,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 +628,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 +742,12 @@ void SimpleFeature::set_extension_types(
   extension_types_ = types;
 }
 
+void SimpleFeature::set_session_types(
+    std::initializer_list<FeatureSessionType> types) {
+  session_types_ = types;
+  session_types_set_ = true;
+}
+
 void SimpleFeature::set_matches(
     std::initializer_list<const char* const> matches) {
   matches_.ClearPatterns();