Pass user session type to extension feature checks

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 27 matching lines @@
     const std::string& extension_id,
     Manifest::Type type,
     Manifest::Location location,
     int manifest_version,
     Feature::Platform platform,
     const Feature* feature) {
   return feature->IsAvailableToManifest(
       extension_id, type, location, manifest_version, platform);
 }
 
-Feature::Availability IsAvailableToContextForBind(const Extension* extension,
-                                                  Feature::Context context,
-                                                  const GURL& url,
-                                                  Feature::Platform platform,
-                                                  const Feature* feature) {
-  return feature->IsAvailableToContext(extension, context, url, platform);
+Feature::Availability IsAvailableToContextForBind(
+    const Extension* extension,
+    Feature::Context context,
+    Feature::SessionType session_type,
+    const GURL& url,
+    Feature::Platform platform,
+    const Feature* feature) {
+  return feature->IsAvailableToContext(extension, context, session_type, url,
+                                       platform);
 }
 
 // TODO(aa): Can we replace all this manual parsing with JSON schema stuff?
 
 void ParseVector(const base::Value* value,
                  std::vector<std::string>* vector) {
   const base::ListValue* list_value = NULL;
   if (!value->GetAsList(&list_value))
     return;
 
@@ skipping 377 matching lines @@
   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,
+    Feature::SessionType session_type,
     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);
   }
 
   // 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, session_type, url, platform));
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
     AvailabilityResult result,
     Manifest::Type type,
     const GURL& url,
     Context context,
     version_info::Channel channel) const {
   switch (result) {
     case IS_AVAILABLE:
@@ skipping 208 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