Introduce session type parameter to extension features

extensions/common/features/simple_feature.h

 // 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.
 
 #ifndef EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_
 #define EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_
 
 #include <stddef.h>
 
 #include <initializer_list>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/gtest_prod_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "components/version_info/version_info.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/features/feature.h"
+#include "extensions/common/features/feature_session_type.h"
 #include "extensions/common/manifest.h"
 
 namespace extensions {
 
 class BaseFeatureProviderTest;
 class ExtensionAPITest;
 class ManifestUnitTest;
 class SimpleFeatureTest;
 
 class SimpleFeature : public Feature {
@@ skipping 74 matching lines @@
   void set_channel(version_info::Channel channel) {
     channel_.reset(new version_info::Channel(channel));
   }
   void set_command_line_switch(base::StringPiece command_line_switch);
   void set_component_extensions_auto_granted(bool granted) {
     component_extensions_auto_granted_ = granted;
   }
   void set_contexts(std::initializer_list<Context> contexts);
   void set_dependencies(std::initializer_list<const char* const> dependencies);
   void set_extension_types(std::initializer_list<Manifest::Type> types);
+  void set_session_types(std::initializer_list<FeatureSessionType> types);
   void set_internal(bool is_internal) { is_internal_ = is_internal; }
   void set_location(Location location) { location_ = location; }
   // set_matches() is an exception to pass-by-value since we construct an
   // URLPatternSet from the vector of strings.
   // TODO(devlin): Pass in an URLPatternSet directly.
   void set_matches(std::initializer_list<const char* const> matches);
   void set_max_manifest_version(int max_manifest_version) {
     max_manifest_version_ = max_manifest_version;
   }
   void set_min_manifest_version(int min_manifest_version) {
@@ skipping 23 matching lines @@
   }
   bool component_extensions_auto_granted() const {
     return component_extensions_auto_granted_;
   }
   const URLPatternSet& matches() const { return matches_; }
 
   std::string GetAvailabilityMessage(AvailabilityResult result,
                                      Manifest::Type type,
                                      const GURL& url,
                                      Context context,
-                                     version_info::Channel channel) const;
+                                     version_info::Channel channel,
+                                     FeatureSessionType session_type) const;
 
   // Handy utilities which construct the correct availability message.
   Availability CreateAvailability(AvailabilityResult result) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   Manifest::Type type) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   const GURL& url) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   Context context) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   version_info::Channel channel) const;
+  Availability CreateAvailability(AvailabilityResult result,
+                                  FeatureSessionType session_type) const;
 
  private:
   friend struct FeatureComparator;
   friend class SimpleFeatureTest;
   FRIEND_TEST_ALL_PREFIXES(BaseFeatureProviderTest, ManifestFeatureTypes);
   FRIEND_TEST_ALL_PREFIXES(BaseFeatureProviderTest, PermissionFeatureTypes);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, DefaultConfigurationFeatures);
   FRIEND_TEST_ALL_PREFIXES(FeaturesGenerationTest, FeaturesTest);
   FRIEND_TEST_ALL_PREFIXES(ManifestUnitTest, Extension);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Blacklist);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, CommandLineSwitch);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ComplexFeatureAvailability);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Context);
+  FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, SessionType);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, FeatureValidation);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, HashedIdBlacklist);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, HashedIdWhitelist);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Inheritance);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Location);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ManifestVersion);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, PackageType);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseContexts);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseLocation);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseManifestVersion);
@@ skipping 19 matching lines @@
   static bool IsValidExtensionId(const std::string& extension_id);
 
   // For clarity and consistency, we handle the default value of each of these
   // members the same way: it matches everything. It is up to the higher level
   // code that reads Features out of static data to validate that data and set
   // sensible defaults.
   std::vector<std::string> blacklist_;
   std::vector<std::string> whitelist_;
   std::vector<std::string> dependencies_;
   std::vector<Manifest::Type> extension_types_;
+  std::vector<FeatureSessionType> session_types_;
   std::vector<Context> contexts_;
   std::vector<Platform> platforms_;
   URLPatternSet matches_;
   Location location_;
   int min_manifest_version_;
   int max_manifest_version_;
   bool component_extensions_auto_granted_;
   bool is_internal_;
   std::string command_line_switch_;
   std::unique_ptr<version_info::Channel> channel_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleFeature);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_