Introduce session type parameter to extension features

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 189 matching lines @@
       return "dev";
     case version_info::Channel::BETA:
       return "beta";
     case version_info::Channel::STABLE:
       return "stable";
   }
   NOTREACHED();
   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>
 std::string ListDisplayNames(const std::vector<EnumType>& enum_types) {
   std::string display_name_list;
   for (size_t i = 0; i < enum_types.size(); ++i) {
     // Pluralize type name.
     display_name_list += GetDisplayName(enum_types[i]) + "s";
     // Comma-separate entries, with an Oxford comma if there is more than 2
     // total entries.
@@ skipping 70 matching lines @@
     platforms["chromeos"] = Feature::CHROMEOS_PLATFORM;
     platforms["linux"] = Feature::LINUX_PLATFORM;
     platforms["mac"] = Feature::MACOSX_PLATFORM;
     platforms["win"] = Feature::WIN_PLATFORM;
 
     channels["trunk"] = version_info::Channel::UNKNOWN;
     channels["canary"] = version_info::Channel::CANARY;
     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;
   std::map<std::string, Feature::Context> contexts;
   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),
       is_internal_(false) {}
 
 SimpleFeature::~SimpleFeature() {}
 
 void SimpleFeature::Parse(const base::DictionaryValue* dictionary) {

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

This badly needs to be rebased.

   static base::LazyInstance<SimpleFeature::Mappings> mappings =
       LAZY_INSTANCE_INITIALIZER;
 
   no_parent_ = false;
   for (base::DictionaryValue::Iterator it(*dictionary);
       !it.IsAtEnd();
       it.Advance()) {
     const std::string& key = it.key();
     const base::Value* value = &it.value();
     if (key == "matches") {
       ParseURLPatterns(dictionary, "matches", &matches_);
     } else if (key == "blacklist") {
       ParseVector(value, &blacklist_);
     } else if (key == "whitelist") {
       ParseVector(value, &whitelist_);
     } else if (key == "dependencies") {
       ParseVector(value, &dependencies_);
     } else if (key == "extension_types") {
       ParseEnumVector<Manifest::Type>(value, &extension_types_,
                                       mappings.Get().extension_types);
     } 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") {
       ParseEnumVector<Platform>(value, &platforms_,
                                 mappings.Get().platforms);
     } else if (key == "min_manifest_version") {
       dictionary->GetInteger("min_manifest_version", &min_manifest_version_);
     } else if (key == "max_manifest_version") {
       dictionary->GetInteger("max_manifest_version", &max_manifest_version_);
     } else if (key == "noparent") {
@@ skipping 79 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_set_ && !base::ContainsValue(session_types_, session)) {
+    return CreateAvailability(INVALID_SESSION_TYPE, session);
+  }
+
   return CheckDependencies(base::Bind(&IsAvailableToManifestForBind,
                                       extension_id,
                                       type,
                                       location,
                                       manifest_version,
                                       platform));
 }
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
     const Extension* extension,
-    SimpleFeature::Context context,
+    Feature::Context context,
     const GURL& url,
     SimpleFeature::Platform platform) const {
   if (extension) {
     Availability result = IsAvailableToManifest(extension->id(),
                                                 extension->GetType(),
                                                 extension->location(),
                                                 extension->manifest_version(),
                                                 platform);
     if (!result.is_available())
       return result;
   }
 
   // TODO(lazyboy): This isn't quite right for Extension Service Worker
   // extension API calls, since there's no guarantee that the extension is
   // "active" in current renderer process when the API permission check is
   // done.
   if (!contexts_.empty() && !base::ContainsValue(contexts_, context))
     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_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(
     AvailabilityResult result,
     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();
     case NOT_FOUND_IN_WHITELIST:
     case FOUND_IN_BLACKLIST:
       return base::StringPrintf(
           "'%s' is not allowed for specified extension ID.",
           name().c_str());
     case INVALID_URL:
       return base::StringPrintf("'%s' is not allowed on %s.",
@@ skipping 23 matching lines @@
     case INVALID_MIN_MANIFEST_VERSION:
       return base::StringPrintf(
           "'%s' requires manifest version of at least %d.",
           name().c_str(),
           min_manifest_version_);
     case INVALID_MAX_MANIFEST_VERSION:
       return base::StringPrintf(
           "'%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.",
           name().c_str());
     case UNSUPPORTED_CHANNEL:
       return base::StringPrintf(
           "'%s' requires %s channel or newer, but this is the %s channel.",
           name().c_str(), GetDisplayName(channel).c_str(),
           GetDisplayName(GetCurrentChannel()).c_str());
     case MISSING_COMMAND_LINE_SWITCH:
       return base::StringPrintf(
           "'%s' requires the '%s' command line switch to be enabled.",
           name().c_str(), command_line_switch_.c_str());
   }
 
   NOTREACHED();
   return std::string();
 }
 
 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(
     AvailabilityResult result,
     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(
     AvailabilityResult result,
     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 {
   return is_internal_;
 }
 
 bool SimpleFeature::IsIdInBlacklist(const std::string& extension_id) const {
   return IsIdInList(extension_id, blacklist_);
 }
 
@@ skipping 83 matching lines @@
 void SimpleFeature::set_dependencies(
     std::initializer_list<const char* const> dependencies) {
   dependencies_.assign(dependencies.begin(), dependencies.end());
 }
 
 void SimpleFeature::set_extension_types(
     std::initializer_list<Manifest::Type> 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();
   for (const auto* pattern : matches)
     matches_.AddPattern(URLPattern(URLPattern::SCHEME_ALL, pattern));
 }
 
 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