Pass user session type to extension feature checks

extensions/common/features/simple_feature_unittest.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 <stddef.h>
 
 #include <string>
 
@@ skipping 316 matching lines @@
   manifest.SetString("app.launch.local_path", "foo.html");
 
   std::string error;
   scoped_refptr<const Extension> extension(Extension::Create(
       base::FilePath(), Manifest::INTERNAL, manifest, Extension::NO_FLAGS,
       &error));
   EXPECT_EQ("", error);
   ASSERT_TRUE(extension.get());
 
   feature.whitelist_.push_back("monkey");
-  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST, feature.IsAvailableToContext(
-      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-      Feature::CHROMEOS_PLATFORM).result());
+  EXPECT_EQ(Feature::NOT_FOUND_IN_WHITELIST,
+            feature
+                .IsAvailableToContext(extension.get(),
+                                      Feature::BLESSED_EXTENSION_CONTEXT,
+                                      Feature::SESSION_TYPE_UNSPECIFIED,
+                                      Feature::CHROMEOS_PLATFORM)
+                .result());
   feature.whitelist_.clear();
 
   feature.extension_types_.clear();
   feature.extension_types_.push_back(Manifest::TYPE_THEME);
   {
     Feature::Availability availability = feature.IsAvailableToContext(
         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-        Feature::CHROMEOS_PLATFORM);
+        Feature::SESSION_TYPE_UNSPECIFIED, Feature::CHROMEOS_PLATFORM);
     EXPECT_EQ(Feature::INVALID_TYPE, availability.result());
     EXPECT_EQ("'somefeature' is only allowed for themes, "
               "but this is a legacy packaged app.",
               availability.message());
   }
 
   feature.extension_types_.clear();
   feature.extension_types_.push_back(Manifest::TYPE_LEGACY_PACKAGED_APP);
   feature.contexts_.clear();
   feature.contexts_.push_back(Feature::UNBLESSED_EXTENSION_CONTEXT);
   feature.contexts_.push_back(Feature::CONTENT_SCRIPT_CONTEXT);
   {
     Feature::Availability availability = feature.IsAvailableToContext(
         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-        Feature::CHROMEOS_PLATFORM);
+        Feature::SESSION_TYPE_UNSPECIFIED, Feature::CHROMEOS_PLATFORM);
     EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
     EXPECT_EQ("'somefeature' is only allowed to run in extension iframes and "
               "content scripts, but this is a privileged page",
               availability.message());
   }
 
   feature.contexts_.push_back(Feature::WEB_PAGE_CONTEXT);
   {
     Feature::Availability availability = feature.IsAvailableToContext(
         extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-        Feature::CHROMEOS_PLATFORM);
+        Feature::SESSION_TYPE_UNSPECIFIED, Feature::CHROMEOS_PLATFORM);
     EXPECT_EQ(Feature::INVALID_CONTEXT, availability.result());
     EXPECT_EQ("'somefeature' is only allowed to run in extension iframes, "
               "content scripts, and web pages, but this is a privileged page",
               availability.message());
   }
 
   feature.contexts_.clear();
   feature.contexts_.push_back(Feature::BLESSED_EXTENSION_CONTEXT);
   feature.set_location(SimpleFeature::COMPONENT_LOCATION);
-  EXPECT_EQ(Feature::INVALID_LOCATION, feature.IsAvailableToContext(
-      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-      Feature::CHROMEOS_PLATFORM).result());
+  EXPECT_EQ(Feature::INVALID_LOCATION,
+            feature
+                .IsAvailableToContext(extension.get(),
+                                      Feature::BLESSED_EXTENSION_CONTEXT,
+                                      Feature::SESSION_TYPE_UNSPECIFIED,
+                                      Feature::CHROMEOS_PLATFORM)
+                .result());
   feature.set_location(SimpleFeature::UNSPECIFIED_LOCATION);
 
-  EXPECT_EQ(Feature::INVALID_PLATFORM, feature.IsAvailableToContext(
-      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-      Feature::UNSPECIFIED_PLATFORM).result());
+  EXPECT_EQ(Feature::INVALID_PLATFORM,
+            feature
+                .IsAvailableToContext(extension.get(),
+                                      Feature::BLESSED_EXTENSION_CONTEXT,
+                                      Feature::SESSION_TYPE_UNSPECIFIED,
+                                      Feature::UNSPECIFIED_PLATFORM)
+                .result());
 
   feature.set_min_manifest_version(22);
-  EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION, feature.IsAvailableToContext(
-      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-      Feature::CHROMEOS_PLATFORM).result());
+  EXPECT_EQ(Feature::INVALID_MIN_MANIFEST_VERSION,
+            feature
+                .IsAvailableToContext(extension.get(),
+                                      Feature::BLESSED_EXTENSION_CONTEXT,
+                                      Feature::SESSION_TYPE_UNSPECIFIED,
+                                      Feature::CHROMEOS_PLATFORM)
+                .result());
   feature.set_min_manifest_version(21);
 
   feature.set_max_manifest_version(18);
-  EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION, feature.IsAvailableToContext(
-      extension.get(), Feature::BLESSED_EXTENSION_CONTEXT,
-      Feature::CHROMEOS_PLATFORM).result());
+  EXPECT_EQ(Feature::INVALID_MAX_MANIFEST_VERSION,
+            feature
+                .IsAvailableToContext(extension.get(),
+                                      Feature::BLESSED_EXTENSION_CONTEXT,
+                                      Feature::SESSION_TYPE_UNSPECIFIED,
+                                      Feature::CHROMEOS_PLATFORM)
+                .result());
   feature.set_max_manifest_version(25);
 }
 
 TEST_F(SimpleFeatureTest, Location) {
   // Component extensions can access any location.
   EXPECT_TRUE(LocationIsAvailable(SimpleFeature::COMPONENT_LOCATION,
                                   Manifest::COMPONENT));
   EXPECT_TRUE(LocationIsAvailable(SimpleFeature::EXTERNAL_COMPONENT_LOCATION,
                                   Manifest::COMPONENT));
   EXPECT_TRUE(
@@ skipping 558 matching lines @@
     EXPECT_NE(Feature::IS_AVAILABLE,
               feature
                   ->IsAvailableToManifest("1", Manifest::TYPE_EXTENSION,
                                           Manifest::INVALID_LOCATION,
                                           Feature::UNSPECIFIED_PLATFORM)
                   .result());
   }
 }
 
 }  // namespace extensions